3 %% Copyright (C) 2000-2019 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
12 \chapter{I socket TCP}
13 \label{cha:TCP_socket}
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}.
22 \section{Il funzionamento di una connessione TCP}
23 \label{sec:TCP_connession}
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.
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.
39 \subsection{La creazione della connessione: il \textit{three way handshake}}
40 \label{sec:TCP_conn_cre}
42 \itindbeg{three~way~handshake}
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 si veda sez.~\ref{sec:tcp_protocol}).} di
55 dati che vengono scambiati) che porta alla creazione di una connessione è la
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
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.
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
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.
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.
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.
101 \centering \includegraphics[width=10cm]{img/three_way_handshake}
102 \caption{Il \textit{three way handshake} del TCP.}
106 \index{numeri~di~sequenza|(}
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'intestazione la presenza di un numero a
111 32 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.
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'intestazione un \textit{acknowledge number}) pari al numero di
121 sequenza che il ricevente si aspetta di ricevere con il pacchetto successivo;
122 dato che il primo pacchetto SYN consuma un byte, nel \textit{three way
123 handshake} il numero di \textit{acknowledge} è sempre pari al numero di
124 sequenza iniziale incrementato di uno; lo stesso varrà anche (vedi
125 fig.~\ref{fig:TCP_close}) per l'\textit{acknowledgement} di un segmento FIN.
127 \index{numeri~di~sequenza|)}
128 \itindend{three~way~handshake}
131 \subsection{Le opzioni TCP.}
132 \label{sec:TCP_TCP_opt}
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:
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}).
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.
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.
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}).
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.
187 La \textit{MSS option} è generalmente supportata da quasi tutte le
188 realizzazioni del protocollo, le ultime due opzioni (trattate
189 nell'\href{http://www.ietf.org/rfc/rfc1323.txt}{RFC~1323}) sono meno comuni;
190 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
191 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
192 elevati. In ogni caso Linux supporta pienamente entrambe queste opzioni
196 \subsection{La terminazione della connessione}
197 \label{sec:TCP_conn_term}
199 Mentre per la creazione di una connessione occorre un interscambio di tre
200 segmenti, la procedura di chiusura ne richiede normalmente quattro. In questo
201 caso la successione degli eventi è la seguente:
204 \item Un processo ad uno dei due capi chiama la funzione \func{close}, dando
205 l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o
206 \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
207 serve ad indicare che si è finito con l'invio dei dati sulla connessione.
209 \item L'altro capo della connessione riceve il segmento FIN e dovrà eseguire
210 la \textsl{chiusura passiva} (o \textit{passive close}). Al FIN, come ad
211 ogni altro pacchetto, viene risposto con un ACK, inoltre il ricevimento del
212 FIN viene segnalato al processo che ha aperto il socket (dopo che ogni altro
213 eventuale dato rimasto in coda è stato ricevuto) come un
214 \textit{end-of-file} sulla lettura: questo perché il ricevimento di un
215 segmento FIN significa che non si riceveranno altri dati sulla connessione.
217 \item Una volta rilevata l'\textit{end-of-file} anche il secondo processo
218 chiamerà la funzione \func{close} sul proprio socket, causando l'emissione
219 di un altro segmento FIN.
221 \item L'altro capo della connessione riceverà il segmento FIN conclusivo e
222 risponderà con un ACK.
225 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
226 normalmente i segmenti scambiati sono quattro. Questo non è vero sempre
227 giacché in alcune situazioni il FIN del passo 1 è inviato insieme a dei dati.
228 Inoltre è possibile che i segmenti inviati nei passi 2 e 3 dal capo che
229 effettua la chiusura passiva, siano accorpati in un singolo segmento. Come per
230 il SYN anche il FIN occupa un byte nel numero di sequenza, per cui l'ACK
231 riporterà un \textit{acknowledge number} incrementato di uno. In
232 fig.~\ref{fig:TCP_close} si è rappresentata graficamente la sequenza di
233 scambio dei segmenti che conclude la connessione.
236 \centering \includegraphics[width=10cm]{img/tcp_close}
237 \caption{La chiusura di una connessione TCP.}
238 \label{fig:TCP_close}
241 Si noti che, nella sequenza di chiusura, fra i passi 2 e 3, è in teoria
242 possibile che si mantenga un flusso di dati dal capo della connessione che
243 deve ancora eseguire la chiusura passiva a quello che sta eseguendo la
244 chiusura attiva. Nella sequenza indicata i dati verrebbero persi, dato che si
245 è chiuso il socket dal lato che esegue la chiusura attiva; esistono tuttavia
246 situazioni in cui si vuole poter sfruttare questa possibilità, usando una
247 procedura che è chiamata \textit{half-close}; torneremo su questo aspetto e su
248 come utilizzarlo in sez.~\ref{sec:TCP_shutdown}, quando parleremo della
249 funzione \func{shutdown}.
251 La emissione del segmento FIN avviene quando il socket viene chiuso, questo
252 però non avviene solo per la chiamata esplicita della funzione \func{close},
253 ma anche alla terminazione di un processo, quando tutti i file vengono chiusi.
254 Questo comporta ad esempio che se un processo viene terminato da un segnale
255 tutte le connessioni aperte verranno chiuse.
257 Infine occorre sottolineare che, benché nella figura (e nell'esempio che
258 vedremo più avanti in sez.~\ref{sec:TCP_echo}) sia stato il client ad eseguire
259 la chiusura attiva, nella realtà questa può essere eseguita da uno qualunque
260 dei due capi della comunicazione (come nell'esempio di
261 fig.~\ref{fig:TCP_daytime_iter_server_code}), e che anche se il caso più
262 comune resta quello del client, ci sono alcuni servizi, il più noto dei quali
263 è l'HTTP 1.0 (con le versioni successive il default è cambiato) per i quali è
264 il server ad effettuare la chiusura attiva.
267 \subsection{Un esempio di connessione}
268 \label{sec:TCP_conn_dia}
270 Come abbiamo visto le operazioni del TCP nella creazione e conclusione di una
271 connessione sono piuttosto complesse, ed abbiamo esaminato soltanto quelle
272 relative ad un andamento normale. In sez.~\ref{sec:TCP_states} vedremo con
273 maggiori dettagli che una connessione può assumere vari stati, che ne
274 caratterizzano il funzionamento, e che sono quelli che vengono riportati dal
275 comando \cmd{netstat}, per ciascun socket TCP aperto, nel campo
278 Non possiamo affrontare qui una descrizione completa del funzionamento del
279 protocollo; un approfondimento sugli aspetti principali si trova in
280 sez.~\ref{sec:tcp_protocol}, ma per una trattazione completa il miglior
281 riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un
282 semplice esempio di connessione e le transizioni che avvengono nei due casi
283 appena citati (creazione e terminazione della connessione).
285 In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
286 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
287 diventa \texttt{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
288 emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
289 finale in cui avviene la gran parte del trasferimento dei dati.
291 Dal lato server in genere invece il passaggio che si opera con l'apertura
292 passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
293 stato \texttt{LISTEN} in cui vengono accettate le connessioni.
295 Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
296 chiama la funzione \func{close} prima di aver ricevuto un
297 \textit{end-of-file} (chiusura attiva) la transizione è verso lo stato
298 \texttt{FIN\_WAIT\_1}; se invece l'applicazione riceve un FIN nello stato
299 \texttt{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato
300 \texttt{CLOSE\_WAIT}.
302 In fig.~\ref{fig:TCP_conn_example} è riportato lo schema dello scambio dei
303 pacchetti che avviene per una un esempio di connessione, insieme ai vari stati
304 che il protocollo viene ad assumere per i due lati, server e client.
307 \centering \includegraphics[width=9cm]{img/tcp_connection}
308 \caption{Schema dello scambio di pacchetti per un esempio di connessione.}
309 \label{fig:TCP_conn_example}
312 La connessione viene iniziata dal client che annuncia una \textit{Maximum
313 Segment Size} di 1460, un valore tipico con Linux per IPv4 su Ethernet, il
314 server risponde con lo stesso valore (ma potrebbe essere anche un valore
317 Una volta che la connessione è stabilita il client scrive al server una
318 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
319 1460 byte annunciati dal server), quest'ultimo riceve la richiesta e
320 restituisce una risposta (che di nuovo supponiamo stare in un singolo
321 segmento). Si noti che l'\textit{acknowledge} della richiesta è mandato
322 insieme alla risposta: questo viene chiamato \textit{piggybacking} ed avviene
323 tutte le volte che il server è sufficientemente veloce a costruire la
324 risposta; in caso contrario si avrebbe prima l'emissione di un ACK e poi
325 l'invio della risposta.
327 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
328 secondo quanto visto in sez.~\ref{sec:TCP_conn_term}; si noti che il capo della
329 connessione che esegue la chiusura attiva entra nello stato
330 \texttt{TIME\_WAIT}, sul cui significato torneremo fra poco.
332 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
333 e uno di risposta) TCP necessiti di ulteriori otto segmenti, se invece si
334 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
335 costo che occorre pagare per avere l'affidabilità garantita da TCP, se si
336 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
337 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
338 trasporto all'interno dell'applicazione.
340 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
341 si hanno in una applicazione di rete, perché non è detto che TCP sia la
342 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
343 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
344 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
345 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
346 dati rispondono meglio alle esigenze che devono essere affrontate.
349 \subsection{Lo stato \texttt{TIME\_WAIT}}
350 \label{sec:TCP_time_wait}
352 Come riportato da Stevens in \cite{UNP1} lo stato \texttt{TIME\_WAIT} è
353 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
354 comune trovare domande su come sia possibile evitare che un'applicazione resti
355 in questo stato lasciando attiva una connessione ormai conclusa; la risposta è
356 che non deve essere fatto, ed il motivo cercheremo di spiegarlo adesso.
358 \itindbeg{Maximum~Segment~Lifetime~(MSL)}
359 Come si è visto nell'esempio precedente (vedi fig.~\ref{fig:TCP_conn_example})
360 \texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che
361 esegue la chiusura attiva resta prima di passare alla chiusura definitiva
362 della connessione. Il tempo in cui l'applicazione resta in questo stato deve
363 essere due volte la \textit{Maximum Segment Lifetime} (da qui in avanti
366 La \textit{Maximum Segment Lifetime} è la stima del massimo periodo di tempo
367 in secondi che un pacchetto IP può vivere sulla rete. Questo tempo è limitato
368 perché ogni pacchetto IP può essere ritrasmesso dai router un numero massimo
369 di volte (detto \textit{hop limit}). Il numero di ritrasmissioni consentito è
370 indicato dal campo TTL dell'intestazione di IP (per maggiori dettagli vedi
371 sez.~\ref{sec:ip_protocol}), e viene decrementato ad ogni passaggio da un
372 router; quando si annulla il pacchetto viene scartato. Siccome il numero è ad
373 8 bit il numero massimo di ``\textsl{salti}'' è di 255, pertanto anche se il
374 TTL (da \textit{time to live}) non è propriamente un limite sul tempo, sulla
375 sua base si può stimare che un pacchetto IP non possa restare nella rete per
376 più un certo numero di secondi, che costituisce la MSL.
377 \itindend{Maximum~Segment~Lifetime~(MSL)}
379 Ogni realizzazione del TCP deve scegliere un valore per la MSL;
380 l'\href{http://www.ietf.org/rfc/rfc1122.txt}{RFC~1122} raccomanda 2 minuti,
381 mentre Linux usa 30 secondi, questo comporta una durata dello stato
382 \texttt{TIME\_WAIT} che a seconda delle realizzazioni può variare fra 1 a 4
383 minuti. Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due
386 \item effettuare in maniera affidabile la terminazione della connessione
387 in entrambe le direzioni.
388 \item consentire l'eliminazione dei segmenti duplicati dalla rete.
391 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
392 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
393 capisce il perché della scelta di un tempo pari al doppio della MSL come
394 durata di questo stato.
396 Il primo dei due motivi precedenti si può capire tornando a
397 fig.~\ref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza
398 (quello del capo che ha eseguito la chiusura attiva) venga perso, chi esegue
399 la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per
400 questo motivo chi esegue la chiusura attiva deve mantenere lo stato della
401 connessione per essere in grado di reinviare l'ACK e chiuderla correttamente.
402 Se non fosse così la risposta sarebbe un RST (un altro tipo si segmento) che
403 verrebbe interpretato come un errore.
405 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
406 connessione allora deve essere in grado di affrontare la perdita di uno
407 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
408 motivo un socket deve rimanere attivo nello stato \texttt{TIME\_WAIT} anche
409 dopo l'invio dell'ultimo ACK, per potere essere in grado di gestirne
410 l'eventuale ritrasmissione, in caso esso venga perduto.
412 Il secondo motivo è più complesso da capire, e necessita di una spiegazione
413 degli scenari in cui può accadere che i pacchetti TCP si possano perdere nella
414 rete o restare intrappolati, per poi riemergere in un secondo tempo.
416 Il caso più comune in cui questo avviene è quello di anomalie
417 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
418 una connessione fra due router si interrompa. In questo caso i protocolli di
419 instradamento dei pacchetti possono impiegare diverso tempo (anche dell'ordine
420 dei minuti) prima di trovare e stabilire un percorso alternativo per i
421 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
422 pacchetti verso un altro e quest'ultimo li rispedisce indietro, o li manda ad
423 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
424 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
426 Se uno di questi pacchetti intrappolati è un segmento TCP, chi l'ha inviato,
427 non ricevendo un ACK in risposta, provvederà alla ritrasmissione e se nel
428 frattempo sarà stata stabilita una strada alternativa il pacchetto ritrasmesso
429 giungerà a destinazione.
431 Ma se dopo un po' di tempo (che non supera il limite dell'MSL, dato che
432 altrimenti verrebbe ecceduto il TTL) l'anomalia viene a cessare, il circolo di
433 instradamento viene spezzato i pacchetti intrappolati potranno essere inviati
434 alla destinazione finale, con la conseguenza di avere dei pacchetti duplicati;
435 questo è un caso che il TCP deve essere in grado di gestire.
437 Allora per capire la seconda ragione per l'esistenza dello stato
438 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
439 connessione fra l'IP \texttt{195.110.112.236} porta 1550 e l'IP
440 \texttt{192.84.145.100} porta 22 (affronteremo il significato delle porte
441 nella prossima sezione), che questa venga chiusa e che poco dopo si
442 ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte
443 (quella che viene detta, essendo gli stessi porte e numeri IP, una nuova
444 \textsl{incarnazione} della connessione precedente); in questo caso ci si
445 potrebbe trovare con dei pacchetti duplicati relativi alla precedente
446 connessione che riappaiono nella nuova.
448 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
449 creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
450 per un periodo di 2 volte la MSL, prima per attendere MSL secondi per essere
451 sicuri che tutti i pacchetti duplicati in arrivo siano stati ricevuti e
452 scartati, o che nel frattempo siano stati eliminati dalla rete, poi altri MSL
453 secondi per essere sicuri che lo stesso avvenga per le risposte nella
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
462 \subsection{I numeri di porta}
463 \label{sec:TCP_port_num}
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.
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.
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.
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:
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).
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.
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.
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.
521 \centering \includegraphics[width=13cm]{img/port_alloc}
522 \caption{Allocazione dei numeri di porta.}
523 \label{fig:TCP_port_alloc}
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
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.
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
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}.
565 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
566 che fare con un'applicazione client/server (come quelle che descriveremo in
567 sez.~\ref{sec:TCP_daytime_application} e sez.~\ref{sec:TCP_echo_application})
568 esamineremo cosa accade con le connessioni nel caso di un server TCP che deve
569 gestire connessioni multiple.
571 Se eseguiamo un \cmd{netstat} su una macchina di prova (il cui indirizzo sia
572 \texttt{195.110.112.152}) potremo avere un risultato del tipo:
574 Active Internet connections (servers and established)
575 Proto Recv-Q Send-Q Local Address Foreign Address State
576 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
577 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
578 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
580 essendo presenti e attivi un server SSH, un server di posta e un DNS per il
583 Questo ci mostra ad esempio che il server SSH ha compiuto un'apertura passiva,
584 mettendosi in ascolto sulla porta 22 riservata a questo servizio, e che si è
585 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
586 associati alle interfacce locali. La notazione \texttt{0.0.0.0} usata da
587 \cmd{netstat} è equivalente all'asterisco utilizzato per il numero di porta,
588 indica il valore generico, e corrisponde al valore \const{INADDR\_ANY}
589 definito in \headfiled{arpa/inet.h} (vedi \ref{tab:TCP_ipv4_addr}).
591 Inoltre si noti come la porta e l'indirizzo di ogni eventuale connessione
592 esterna non sono specificati; in questo caso la \textit{socket pair} associata
593 al socket potrebbe essere indicata come (\texttt{*:22}, \texttt{*:*}), usando
594 anche per gli indirizzi l'asterisco come carattere che indica il valore
597 Dato che in genere una macchina è associata ad un solo indirizzo IP, ci si può
598 chiedere che senso abbia l'utilizzo dell'indirizzo generico per specificare
599 l'indirizzo locale; ma a parte il caso di macchine che hanno più di un
600 indirizzo IP (il cosiddetto \textit{multihoming}) esiste sempre anche
601 l'indirizzo di \textit{loopback}, per cui con l'uso dell'indirizzo generico si
602 possono accettare connessioni indirizzate verso uno qualunque degli indirizzi
603 IP presenti. Ma, come si può vedere nell'esempio con il DNS che è in ascolto
604 sulla porta 53, è possibile anche restringere l'accesso ad uno specifico
605 indirizzo, cosa che nel caso è fatta accettando solo connessioni che arrivino
606 sull'interfaccia di \textit{loopback}.
608 Una volta che ci si vorrà collegare a questa macchina da un'altra, per esempio
609 quella con l'indirizzo \texttt{192.84.146.100}, si dovrà lanciare su
610 quest'ultima un client \cmd{ssh} per creare una connessione, e il kernel gli
611 assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà
612 espressa dalla \textit{socket pair} (\texttt{192.84.146.100:21100},
613 \texttt{195.110.112.152:22}).
615 Alla ricezione della richiesta dal client il server creerà un processo figlio
616 per gestire la connessione, se a questo punto eseguiamo nuovamente il
617 programma \cmd{netstat} otteniamo come risultato:
619 Active Internet connections (servers and established)
620 Proto Recv-Q Send-Q Local Address Foreign Address State
621 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
622 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
623 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
624 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
627 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
628 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che utilizza anch'esso
629 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
630 il processo figlio gestisce la connessione mentre il padre resta in ascolto
631 sul socket originale.
633 Se a questo punto lanciamo un'altra volta il client \cmd{ssh} per una seconda
634 connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
637 Active Internet connections (servers and established)
638 Proto Recv-Q Send-Q Local Address Foreign Address State
639 tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
640 tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
641 tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
642 tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
643 tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
645 cioè il client effettuerà la connessione usando un'altra porta effimera: con
646 questa sarà aperta la connessione, ed il server creerà un altro processo
649 Tutto ciò mostra come il TCP, per poter gestire le connessioni con un server
650 concorrente, non può suddividere i pacchetti solo sulla base della porta di
651 destinazione, ma deve usare tutta l'informazione contenuta nella
652 \textit{socket pair}, compresa la porta dell'indirizzo remoto. E se andassimo
653 a vedere quali sono i processi (ad esempio con il comando \cmd{fuser}, o con
654 \cmd{lsof}, o usando l'opzione \texttt{-p}) a cui fanno riferimento i vari
655 socket vedremmo che i pacchetti che arrivano dalla porta remota 21100 vanno al
656 primo figlio e quelli che arrivano alla porta 21101 al secondo.
659 \section{Le funzioni di base per la gestione dei socket}
660 \label{sec:TCP_functions}
662 In questa sezione descriveremo in maggior dettaglio le varie funzioni che
663 vengono usate per la gestione di base dei socket TCP, non torneremo però sulla
664 funzione \func{socket}, che è già stata esaminata accuratamente nel capitolo
665 precedente in sez.~\ref{sec:sock_creation}. Pur trattandole principalmente dal
666 punto di vista dei socket TCP, daremo brevemente conto del loro comportamento
667 anche per altri tipi di socket.
670 \subsection{La funzione \func{bind}}
671 \label{sec:TCP_func_bind}
673 La funzione \funcd{bind} assegna un indirizzo locale ad un
674 socket,\footnote{nel nostro caso la utilizzeremo per socket TCP, ma la
675 funzione è generica e deve essere usata per qualunque tipo di socket
676 \const{SOCK\_STREAM} prima che questo possa accettare connessioni.} ed è
677 usata cioè per specificare la prima parte dalla \textit{socket pair}. Viene
678 usata sul lato server per specificare la porta (e gli eventuali indirizzi
679 locali) su cui poi ci si porrà in ascolto. Il prototipo della funzione è il
685 \fdecl{int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t
687 \fdesc{Assegna un indirizzo ad un socket.}
690 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
691 caso \var{errno} assumerà uno dei valori:
693 \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
694 sufficienti privilegi.
695 \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo
696 richiesto oppure quando non si è richiesta un porta specifica per avere
697 una porta effimera non ve ne sono di disponibili nell'intervallo ad esse
698 riservato correntemente in uso.
699 \item[\errcode{EBADF}] il file descriptor non è valido.
700 \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato,
701 o \param{addrlen} è sbagliata, o \param{serv\_addr} non è valido per il
703 \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
705 ed \errval{EFAULT} nel suo significato generico; inoltre per i socket di
706 tipo \const{AF\_UNIX}:
708 \item[\errcode{EADDRNOTAVAIL}] il tipo di indirizzo specificato non è
711 ed \errval{ELOOP}, \errval{ENAMETOOLONG}, \errval{ENOENT}, \errval{ENOMEM},
712 \errval{ENOTDIR} e \errval{EROFS} nel loro significato generico.}
715 Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
716 \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
717 l'indirizzo (locale) del socket e la dimensione della struttura che lo
718 contiene, secondo quanto già trattato in sez.~\ref{sec:sock_sockaddr}.
720 Con i socket TCP la chiamata \func{bind} permette di specificare l'indirizzo,
721 la porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
722 nota che assegnano all'avvio, se questo non viene fatto è il kernel a
723 scegliere una porta effimera quando vengono eseguite la funzioni
724 \func{connect} o \func{listen}, ma se questo è normale per il client non lo è
725 per il server\footnote{un'eccezione a tutto ciò sono i server che usano RPC.
726 In questo caso viene fatta assegnare dal kernel una porta effimera che poi
727 viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
728 demone che deve essere contattato dai client per ottenere la porta effimera
729 su cui si trova il server.} che in genere viene identificato dalla porta su
730 cui risponde (l'elenco di queste porte, e dei relativi servizi, è in
731 \conffile{/etc/services}).
733 Con \func{bind} si può assegnare un indirizzo IP specifico ad un socket,
734 purché questo appartenga ad una interfaccia della macchina. Per un client TCP
735 questo diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati
736 sul socket, mentre per un server TCP questo restringerà l'accesso al socket
737 solo alle connessioni che arrivano verso tale indirizzo.
739 Normalmente un client non specifica mai l'indirizzo di un socket, ed il kernel
740 sceglie l'indirizzo di origine quando viene effettuata la connessione, sulla
741 base dell'interfaccia usata per trasmettere i pacchetti, che dipenderà dalle
742 regole di instradamento usate per raggiungere il server (è comunque possibile
743 impostarlo in maniera specifica con i comandi di gestione avanzata del
744 routing, vedi sez.~7.3.4 di \cite{AGL}). Se un server non specifica il suo
745 indirizzo locale il kernel userà come indirizzo di origine l'indirizzo di
746 destinazione specificato dal SYN del client.
748 Per specificare un indirizzo generico, con IPv4 si usa il valore
749 \const{INADDR\_ANY}, il cui valore, come accennato in
750 sez.~\ref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
751 fig.~\ref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione
752 immediata del tipo: \includecodesnip{listati/serv_addr_sin_addr.c}
754 Si noti che si è usato \func{htonl} per assegnare il valore
755 \const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
756 inutile. Si tenga presente comunque che tutte le costanti \val{INADDR\_}
757 (riportate in tab.~\ref{tab:TCP_ipv4_addr}) sono definite secondo
758 l'\textit{endianness} della macchina, ed anche se esse possono essere
759 invarianti rispetto all'ordinamento dei bit, è comunque buona norma usare
760 sempre la funzione \func{htonl}.
765 \begin{tabular}[c]{|l|l|}
767 \textbf{Costante} & \textbf{Significato} \\
770 \constd{INADDR\_ANY} & Indirizzo generico (\texttt{0.0.0.0})\\
771 \constd{INADDR\_BROADCAST}& Indirizzo di \textit{broadcast}.\\
772 \constd{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback}
773 (\texttt{127.0.0.1}).\\
774 \constd{INADDR\_NONE} & Indirizzo errato.\\
777 \caption{Costanti di definizione di alcuni indirizzi generici per IPv4.}
778 \label{tab:TCP_ipv4_addr}
781 L'esempio precedente funziona correttamente con IPv4 poiché che l'indirizzo è
782 rappresentabile anche con un intero a 32 bit; non si può usare lo stesso
783 metodo con IPv6, in cui l'indirizzo deve necessariamente essere specificato
784 con una struttura, perché il linguaggio C non consente l'uso di una struttura
785 costante come operando a destra in una assegnazione.
787 Per questo motivo nell'header \headfile{netinet/in.h} è definita una variabile
788 \var{in6addr\_any} (dichiarata come \dirct{extern}, ed inizializzata dal
789 sistema al valore \constd{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
790 assegnazione del tipo: \includecodesnip{listati/serv_addr_sin6_addr.c} in
791 maniera analoga si può utilizzare la variabile \var{in6addr\_loopback} per
792 indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata
793 staticamente a \constd{IN6ADRR\_LOOPBACK\_INIT}.
796 \subsection{La funzione \func{connect}}
797 \label{sec:TCP_func_connect}
799 La funzione \funcd{connect} è usata da un client TCP per stabilire la
800 connessione con un server TCP, ma la funzione è generica e supporta vari tipi
801 di socket. La differenza è che per socket senza connessione come quelli di
802 tipo \const{SOCK\_DGRAM} la sua chiamata si limiterà ad impostare l'indirizzo
803 dal quale e verso il quale saranno inviati e ricevuti i pacchetti, mentre per
804 socket di tipo \const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET} essa attiverà
805 la procedura di avvio della connessione (nel caso del TCP il \textit{three way
806 handshake}). Il suo prototipo è il seguente:
811 \fdecl{int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t
813 \fdesc{Stabilisce una connessione fra due socket.}
816 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
817 caso \var{errno} assumerà uno dei valori:
819 \item[\errcode{EACCES}, \errcode{EPERM}] si è tentato di eseguire una
820 connessione ad un indirizzo \textit{broadcast} senza che il socket fosse
821 stato abilitato per il \textit{broadcast}.
822 \item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
823 corretta nel relativo campo.
824 \item[\errcode{EAGAIN}] non ci sono più porte locali libere.
825 \item[\errcode{EALREADY}] il socket è non bloccante (vedi
826 sez.~\ref{sec:file_noblocking}) e un tentativo precedente di connessione
827 non si è ancora concluso.
828 \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
830 \item[\errcode{EINPROGRESS}] il socket è non bloccante (vedi
831 sez.~\ref{sec:file_noblocking}) e la connessione non può essere conclusa
833 \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
834 \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
837 ed inoltre \errval{EADDRINUSE}, \errval{EBADF}, \errval{EFAULT},
838 \errval{EINTR}, \errval{EISCONN} e \errval{ENOTSOCK} e nel loro significato
842 Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
843 \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
844 l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
845 socket, già descritta in sez.~\ref{sec:sock_sockaddr}.
847 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
848 numero di porta del server a cui ci si vuole connettere usando le funzioni
849 illustrate in sez.~\ref{sec:sock_addr_func} come mostrato nell'esempio che
850 vedremo in sez.~\ref{sec:TCP_daytime_client}.
852 Nel caso di socket TCP la funzione \func{connect} avvia il \textit{three way
853 handshake}, e ritorna solo quando la connessione è stabilita o si è
854 verificato un errore. Le possibili cause di errore sono molteplici (ed i
855 relativi codici riportati sopra), quelle che però dipendono dalla situazione
856 della rete e non da errori o problemi nella chiamata della funzione sono le
859 \item Il client non riceve risposta al SYN: l'errore restituito è
860 \errcode{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla
861 chiamata di \func{connect}, un altro dopo 6 secondi, un terzo dopo 24
862 secondi, se dopo 75 secondi non ha ricevuto risposta viene ritornato
863 l'errore. Linux invece ripete l'emissione del SYN ad intervalli di 30
864 secondi per un numero di volte che può essere stabilito dall'utente. Questo
865 può essere fatto a livello globale con una opportuna \func{sysctl} (o più
866 semplicemente scrivendo il valore voluto in
867 \sysctlfile{net/ipv4/tcp\_syn\_retries}, vedi
868 sez.~\ref{sec:sock_ipv4_sysctl}) e a livello di singolo socket con l'opzione
869 \const{TCP\_SYNCNT} (vedi sez.~\ref{sec:sock_tcp_udp_options}). Il valore
870 predefinito per la ripetizione dell'invio è di 5 volte, che comporta un
871 timeout dopo circa 180 secondi.
873 \item Il client riceve come risposta al SYN un RST significa che non c'è
874 nessun programma in ascolto per la connessione sulla porta specificata (il
875 che vuol dire probabilmente che o si è sbagliato il numero della porta o che
876 non è stato avviato il server), questo è un errore fatale e la funzione
877 ritorna non appena il RST viene ricevuto riportando un errore
878 \errcode{ECONNREFUSED}.
880 Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
881 dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
882 quando arriva un SYN per una porta che non ha nessun server in ascolto,
883 quando il TCP abortisce una connessione in corso, quando TCP riceve un
884 segmento per una connessione che non esiste.
886 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
887 destinazione non raggiungibile. In questo caso dato che il messaggio può
888 essere dovuto ad una condizione transitoria si ripete l'emissione dei SYN
889 come nel caso precedente, fino al timeout, e solo allora si restituisce il
890 codice di errore dovuto al messaggio ICMP, che da luogo ad un
891 \errcode{ENETUNREACH}.
895 Se si fa riferimento al diagramma degli stati del TCP riportato in
896 fig.~\ref{fig:TCP_state_diag} la funzione \func{connect} porta un socket dallo
897 stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket appena
898 creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento dell'ACK,
899 nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il socket
900 non è più utilizzabile e deve essere chiuso.
902 Si noti infine che con la funzione \func{connect} si è specificato solo
903 indirizzo e porta del server, quindi solo una metà della \textit{socket pair};
904 essendo questa funzione usata nei client l'altra metà contenente indirizzo e
905 porta locale viene lasciata all'assegnazione automatica del kernel, e non è
906 necessario effettuare una \func{bind}.
909 \subsection{La funzione \func{listen}}
910 \label{sec:TCP_func_listen}
912 La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
913 come dice il nome, per metterlo in ascolto di eventuali
914 connessioni;\footnote{questa funzione può essere usata con socket che
915 supportino le connessioni, cioè di tipo \const{SOCK\_STREAM} o
916 \const{SOCK\_SEQPACKET}.} in sostanza l'effetto della funzione è di portare
917 il socket dallo stato \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si
918 chiama la funzione in un server dopo le chiamate a \func{socket} e \func{bind}
919 e prima della chiamata ad \func{accept}. Il prototipo della funzione, come
920 definito dalla pagina di manuale, è:
924 \fdecl{int listen(int sockfd, int backlog)}
925 \fdesc{Pone un socket in attesa di una connessione.}
928 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
929 caso \var{errno} assumerà uno dei valori:
931 \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
932 \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
934 \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
935 \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
941 La funzione pone il socket specificato da \param{sockfd} in modalità passiva e
942 predispone una coda per le connessioni in arrivo di lunghezza pari a
943 \param{backlog}. La funzione si può applicare solo a socket di tipo
944 \const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}. L'argomento \param{backlog}
945 indica il numero massimo di connessioni pendenti accettate; se esso viene
946 ecceduto il client al momento della richiesta della connessione riceverà un
947 errore di tipo \errcode{ECONNREFUSED}, o se il protocollo, come accade nel
948 caso del TCP, supporta la ritrasmissione, la richiesta sarà ignorata in modo
949 che la connessione possa venire ritentata.
951 Per capire meglio il significato di tutto ciò occorre approfondire la modalità
952 con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
953 infatti vengono mantenute due code:
955 \item La coda delle connessioni incomplete (\textit{incomplete connection
956 queue}) che contiene una voce per ciascun socket per il quale è arrivato
957 un SYN ma il \textit{three way handshake} non si è ancora concluso. Questi
958 socket sono tutti nello stato \texttt{SYN\_RECV}.
959 \item La coda delle connessioni complete (\textit{complete connection queue})
960 che contiene una voce per ciascun socket per il quale il \textit{three way
961 handshake} è stato completato ma ancora \func{accept} non è ritornata.
962 Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
965 Lo schema di funzionamento è descritto in fig.~\ref{fig:TCP_listen_backlog}:
966 quando arriva un segmento SYN da un client il kernel crea una voce nella coda
967 delle connessioni incomplete e risponde con il segmento SYN$+$ACK. La voce
968 resterà nella coda delle connessioni incomplete fino al ricevimento del
969 segmento ACK dal client o fino ad un timeout.
971 Nel caso di completamento del \textit{three way handshake} la voce viene
972 spostata nella coda delle connessioni complete. Quando il processo chiama la
973 funzione \func{accept} (vedi sez.~\ref{sec:TCP_func_accept}) gli viene passata
974 la prima voce nella coda delle connessioni complete, oppure, se la coda è
975 vuota, il processo viene posto in attesa in stato di \textit{sleep} e
976 risvegliato all'arrivo della prima connessione completa.
979 \centering \includegraphics[width=12cm]{img/tcp_listen_backlog}
980 \caption{Schema di funzionamento delle code delle connessioni complete ed
982 \label{fig:TCP_listen_backlog}
985 Storicamente il valore dell'argomento \param{backlog} era corrispondente al
986 massimo valore della somma del numero di voci possibili per ciascuna delle due
987 code. Stevens in \cite{UNP1} riporta che BSD ha sempre applicato un fattore di
988 1.5 a detto valore, e fornisce una tabella con i risultati ottenuti con vari
989 kernel, compreso anche il vecchio Linux 2.0, che mostrano le differenze fra
990 diverse realizzazioni.
992 In Linux il significato di questo valore è cambiato a partire dal kernel 2.2
993 per prevenire il \textit{denial of service} chiamato \itindex{SYN~flood}
994 \textit{SYN flood}. Questo attacco si basa sull'emissione da parte
995 dell'attaccante di un grande numero di segmenti SYN indirizzati verso una
996 porta, forgiati con indirizzo IP fasullo (con la tecnica che viene detta
997 \textit{ip spoofing}); in questo modo i segmenti SYN$+$ACK di risposta vanno
998 perduti e la coda delle connessioni incomplete viene saturata, impedendo di
999 fatto ulteriori connessioni.
1001 Per ovviare a questo problema il significato del \param{backlog} è stato
1002 cambiato e adesso indica la lunghezza della coda delle connessioni
1003 complete. La lunghezza della coda delle connessioni incomplete può essere
1004 ancora controllata ma occorre usare esplicitamente la funzione \func{sysctl}
1005 con il parametro \constd{NET\_TCP\_MAX\_SYN\_BACKLOG} o scrivere il valore
1006 direttamente sul file \sysctlfile{net/ipv4/tcp\_max\_syn\_backlog}.
1008 Quando si attiva la protezione dei \textit{syncookies} però (con l'opzione da
1009 compilare nel kernel e da attivare usando \func{sysctl} o scrivendo nel file
1010 \sysctlfile{net/ipv4/tcp\_syncookies}, vedi sez.~\ref{sec:sock_ipv4_sysctl})
1011 questo valore viene ignorato e non esiste più un valore massimo. In ogni caso
1012 in Linux il valore di \param{backlog} viene sempre troncato ad un massimo di
1013 \const{SOMAXCONN} se è superiore a detta costante (che di default vale 128);
1014 per i kernel precedenti il 2.4.25 questo valore era fisso e non modificabile,
1015 nelle versioni successive può essere controllato con un parametro di
1016 \func{sysctl}, o scrivendo nel file \sysctlfile{net/core/somaxconn}
1017 (vedi sez.~\ref{sec:sock_ioctl_IP}).
1019 La scelta storica per il valore assegnato a questo argomento era di 5, e
1020 alcuni vecchi kernel non supportavano neanche valori superiori, ma la
1021 situazione corrente è molto cambiata per via della presenza di server web che
1022 devono gestire un gran numero di connessioni per cui un tale valore non è più
1023 adeguato. Non esiste comunque una risposta univoca per la scelta del valore,
1024 per questo non conviene specificarlo con una costante (il cui cambiamento
1025 richiederebbe la ricompilazione del server) ma usare piuttosto una variabile
1026 di ambiente (vedi sez.~\ref{sec:proc_environ}).
1028 Stevens tratta accuratamente questo argomento in \cite{UNP1}, con esempi presi
1029 da casistiche reali trovate su dei server web, ed in particolare evidenzia
1030 come non sia più vero che il compito principale della coda sia quello di
1031 gestire il caso in cui il server è occupato fra chiamate successive alla
1032 \func{accept} (per cui la coda più occupata sarebbe quella delle connessioni
1033 completate), ma piuttosto quello di gestire la presenza di un gran numero di
1034 SYN in attesa di concludere il \textit{three way handshake}.
1036 Infine va messo in evidenza che, nel caso di socket TCP, quando un segmento
1037 SYN arriva con tutte le code piene, il pacchetto verrà semplicemente
1038 ignorato. Questo avviene perché la condizione in cui le code sono piene è
1039 ovviamente transitoria, per cui se il client ritrasmette in seguito un
1040 segmento SYN, come previsto dal protocollo, è probabile che essendo passato un
1041 po' di tempo esso possa trovare nella coda lo spazio per una nuova
1044 Se al contrario si rispondesse immediatamente con un segmento RST, per
1045 indicare che è impossibile effettuare la connessione, la chiamata a
1046 \func{connect} eseguita dal client fallirebbe ritornando una condizione di
1047 errore. In questo modo si sarebbe costretti ad inserire nell'applicazione la
1048 gestione dei tentativi di riconnessione, che invece grazie a questa modalità
1049 di funzionamento viene effettuata in maniera trasparente dal protocollo
1053 \subsection{La funzione \func{accept}}
1054 \label{sec:TCP_func_accept}
1056 La funzione \funcd{accept} è chiamata da un server per gestire la connessione,
1057 nel caso di TCP una volta che sia stato completato il \textit{three way
1058 handshake};\footnote{come le precedenti, la funzione è generica ed è
1059 utilizzabile su socket di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET}
1060 e \const{SOCK\_RDM}, ma qui la tratteremo solo per gli aspetti riguardanti
1061 le connessioni con TCP.} la funzione restituisce un nuovo socket descriptor
1062 su cui si potrà operare per effettuare la comunicazione. Se non ci sono
1063 connessioni completate il processo viene messo in attesa. Il prototipo della
1064 funzione è il seguente:
1067 \fhead{sys/socket.h}
1068 \fdecl{int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
1069 \fdesc{Accetta una connessione sul socket specificato.}
1072 {La funzione ritorna un numero di socket descriptor positivo in caso di
1073 successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
1076 \item[\errcode{EAGAIN} o \errcode{EWOULDBLOCK}] il socket è stato impostato
1077 come non bloccante (vedi sez.~\ref{sec:file_noblocking}), e non ci sono
1078 connessioni in attesa di essere accettate. In generale possono essere
1079 restituiti entrambi i valori, per cui se si ha a cuore la portabilità
1080 occorre controllare entrambi.
1081 \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1083 \item[\errcode{ECONNABORTED}] la connessione è stata abortita.
1084 \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
1085 \item[\errcode{EINVAL}] il socket non è in ascolto o \param{addrlen} non ha
1087 \item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che
1088 l'allocazione della memoria è limitata dai limiti sui buffer dei socket,
1089 non dalla memoria di sistema.
1090 \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1091 \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
1093 \item[\errcode{EPERM}] le regole del firewall non consentono la connessione.
1095 ed inoltre nel loro significato generico: \errval{EFAULT}, \errval{EMFILE},
1096 \errval{ENFILE}; infine a seconda del protocollo e del kernel possono essere
1097 restituiti errori di rete relativi al nuovo socket come: \errval{ENOSR},
1098 \errval{ESOCKTNOSUPPORT}, \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT},
1099 \errval{ERESTARTSYS}.}
1102 La funzione estrae la prima connessione relativa al socket \param{sockfd} in
1103 attesa sulla coda delle connessioni complete, che associa ad nuovo socket con
1104 le stesse caratteristiche di \param{sockfd}. Il socket originale non viene
1105 toccato e resta nello stato di \texttt{LISTEN}, mentre il nuovo socket viene
1106 posto nello stato \texttt{ESTABLISHED}.
1108 I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è un
1109 \textit{valure-result argument} passato con un puntatore per riavere indietro
1110 il valore) sono usati rispettivamente per ottenere l'indirizzo del client da
1111 cui proviene la connessione e la lunghezza dello stesso; la dimensione dipende
1112 da quale famiglia di indirizzi si sta utilizzando. Prima della
1113 chiamata \param{addrlen} deve essere inizializzato alle dimensioni della
1114 struttura degli indirizzi cui punta \param{addr} (un numero positivo); al
1115 ritorno della funzione \param{addrlen} conterrà il numero di byte scritti
1116 dentro \param{addr}. Se questa informazione non interessa basterà
1117 inizializzare a \val{NULL} detti puntatori.
1119 Se la funzione ha successo restituisce il descrittore di un nuovo socket
1120 creato dal kernel (detto \textit{connected socket}) a cui viene associata la
1121 prima connessione completa (estratta dalla relativa coda, vedi
1122 sez.~\ref{sec:TCP_func_listen}) che il client ha effettuato verso il socket
1123 \param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato
1124 all'inizio e messo in ascolto con \func{listen}, e non viene toccato dalla
1125 funzione. Se non ci sono connessioni pendenti da accettare la funzione mette
1126 in attesa il processo\footnote{a meno che non si sia impostato il socket per
1127 essere non bloccante (vedi sez.~\ref{sec:file_noblocking}), nel qual caso
1128 ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di
1129 operazione in sez.~\ref{sec:TCP_sock_multiplexing}.} fintanto che non ne
1132 La funzione può essere usata solo con socket che supportino la connessione
1133 (cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
1134 \const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
1135 esplicita della connessione,\footnote{attualmente in Linux solo DECnet ha
1136 questo comportamento.} la funzione opera solo l'estrazione dalla coda delle
1137 connessioni, la conferma della connessione viene eseguita implicitamente dalla
1138 prima chiamata ad una \func{read} o una \func{write}, mentre il rifiuto della
1139 connessione viene eseguito con la funzione \func{close}.
1141 Si tenga presente che con Linux, seguendo POSIX.1, è sufficiente includere
1142 \texttt{sys/socket.h}, ma alcune implementazioni di altri sistemi possono
1143 richiedere l'inclusione di \texttt{sys/types.h}, per cui dovendo curare la
1144 portabilità può essere il caso di includere anche questo file. Inoltre Linux
1145 presenta un comportamento diverso nella gestione degli errori rispetto ad
1146 altre realizzazioni dei socket BSD, infatti la funzione \func{accept} passa
1147 gli errori di rete pendenti sul nuovo socket come codici di errore per
1148 \func{accept}, per cui l'applicazione deve tenerne conto ed eventualmente
1149 ripetere la chiamata alla funzione come per l'errore di \errcode{EAGAIN}
1150 (torneremo su questo in sez.~\ref{sec:TCP_echo_critical}).
1152 Un'altra differenza con BSD è che la funzione non fa ereditare al nuovo socket
1153 i flag del socket originale, come \const{O\_NONBLOCK},\footnote{ed in generale
1154 tutti quelli che si possono impostare con \func{fcntl}, vedi
1155 sez.~\ref{sec:file_fcntl_ioctl}.} che devono essere rispecificati ogni
1156 volta. Tutto questo deve essere tenuto in conto se si devono scrivere
1157 programmi portabili. Per poter effettuare questa impostazione in maniera
1158 atomica, senza dover ricorrere ad ulteriori chiamate a \func{fcntl} su Linux è
1159 disponibile anche la funzione \funcd{accept4}, il cui prototipo è:\footnote{la
1160 funzione è utilizzabile solo se si è definito la macro \macro{\_GNU\_SOURCE}
1161 ed ovviamente non è portabile.}
1164 \fhead{sys/socket.h}
1165 \fdecl{int accept4(int sockfd, struct sockaddr *addr, socklen\_t *addrlen, int
1167 \fdesc{Accetta una connessione sul socket specificato.}
1170 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1171 caso \var{errno} assumerà gli stessi valori di \func{accept}.}
1174 La funzione aggiunge un quarto argomento \param{flags} usato come maschera
1175 binaria, e se questo è nullo il suo comportamento è identico a quello di
1176 \func{accept}. Con \param{flags} si possono impostare contestualmente
1177 all'esecuzione sul file descriptor restituito i due flag di
1178 \const{O\_NONBLOCK} e \const{O\_CLOEXEC}, fornendo un valore che sia un OR
1179 aritmetico delle costanti in tab.\ref{tab:accept4_flags_arg}.
1184 \begin{tabular}[c]{|l|l|}
1186 \textbf{Costante} & \textbf{Significato} \\
1189 \constd{SOCK\_NONBLOCK} & imposta sul file descriptor restituito il flag
1190 di \const{O\_NONBLOCK}\\
1191 \constd{SOCK\_NOXEC} & imposta sul file descriptor restituito il flag
1192 di \const{O\_CLOEXEC}\\
1195 \caption{Costanti per i possibili valori dell'argomento \param{flags} di
1197 \label{tab:accept4_flags_arg}
1200 Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
1201 funzionamento di un server: in generale infatti c'è sempre un solo socket in
1202 ascolto, detto per questo \textit{listening socket}, che resta per tutto il
1203 tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai
1204 nuovi socket, detti \textit{connected socket}, ritornati da \func{accept}, che
1205 si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono
1206 utilizzati per lo scambio dei dati, che avviene su di essi, fino alla chiusura
1207 della connessione. Si può riconoscere questo schema anche nell'esempio
1208 elementare di fig.~\ref{fig:TCP_daytime_iter_server_code}, dove per ogni
1209 connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei
1213 \subsection{Le funzioni \func{getsockname} e \func{getpeername}}
1214 \label{sec:TCP_get_names}
1216 Oltre a tutte quelle viste finora, dedicate all'utilizzo dei socket, esistono
1217 alcune funzioni ausiliarie che possono essere usate per recuperare alcune
1218 informazioni relative ai socket ed alle connessioni ad essi associate. Le due
1219 più elementari sono le seguenti, usate per ottenere i dati relativi alla
1220 \textit{socket pair} associata ad un certo socket. La prima è
1221 \funcd{getsockname} e serve ad ottenere l'indirizzo locale associato ad un
1222 socket; il suo prototipo è:
1225 \fhead{sys/socket.h}
1226 \fdecl{int getsockname(int sockfd, struct sockaddr *name, socklen\_t *namelen)}
1227 \fdesc{Legge l'indirizzo locale di un socket.}
1230 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1231 caso \var{errno} assumerà uno dei valori:
1233 \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1235 \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
1236 \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1237 eseguire l'operazione.
1239 ed \errval{EFAULT} nel suo significato generico.}
1242 La funzione restituisce la struttura degli indirizzi del socket \param{sockfd}
1243 nella struttura indicata dal puntatore \param{name} la cui lunghezza è
1244 specificata tramite l'argomento \param{namlen}. Quest'ultimo è un
1245 \textit{value result argument} e pertanto viene passato come indirizzo per
1246 avere indietro anche il numero di byte effettivamente scritti nella struttura
1247 puntata da \param{name}. Si tenga presente che se si è utilizzato un buffer
1248 troppo piccolo per \param{name} l'indirizzo risulterà troncato.
1250 La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un
1251 socket; ad esempio può essere usata da un client (che usualmente non chiama
1252 \func{bind}) per ottenere l'indirizzo IP e la porta locale associati al socket
1253 restituito da una \func{connect}, o da un server che ha chiamato \func{bind}
1254 su un socket usando $0$ come porta locale per ottenere il numero di porta
1255 effimera assegnato dal kernel.
1257 Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se
1258 chiamata dopo il completamento di una connessione sul socket restituito da
1259 \func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
1260 quella connessione. Invece tutte le volte che si vuole avere l'indirizzo
1261 remoto di un socket si usa la funzione \funcd{getpeername}, il cui prototipo
1265 \fhead{sys/socket.h}
1266 \fdecl{int getpeername(int sockfd, struct sockaddr * name, socklen\_t *
1268 \fdesc{Legge l'indirizzo remoto di un socket.}
1271 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
1272 caso \var{errno} assumerà uno dei valori:
1274 \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
1276 \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
1277 eseguire l'operazione.
1278 \item[\errcode{ENOTCONN}] il socket non è connesso.
1279 \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
1281 ed \errval{EFAULT} nel suo significato generico.}
1285 La funzione è identica a \func{getsockname}, ed usa la stessa sintassi, ma
1286 restituisce l'indirizzo remoto del socket, cioè quello associato all'altro
1287 capo della connessione. Ci si può chiedere a cosa serva questa funzione dato
1288 che dal lato client l'indirizzo remoto è sempre noto quando si esegue la
1289 \func{connect} mentre dal lato server si possono usare, come vedremo in
1290 fig.~\ref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di
1293 Il fatto è che in generale quest'ultimo caso non è sempre possibile. In
1294 particolare questo avviene quando il server, invece di gestire la connessione
1295 direttamente in un processo figlio, come vedremo nell'esempio di server
1296 concorrente di sez.~\ref{sec:TCP_daytime_cunc_server}, lancia per ciascuna
1297 connessione un altro programma, usando \func{exec}. Questa ad esempio è la
1298 modalità con cui opera il \textsl{super-server} \cmd{xinetd}, che può gestire
1299 tutta una serie di servizi diversi, eseguendo su ogni connessione ricevuta
1300 sulle porte tenute sotto controllo, il relativo server.
1302 In questo caso benché il processo figlio abbia una immagine della memoria che
1303 è copia di quella del processo padre (e contiene quindi anche la struttura
1304 ritornata da \func{accept}), all'esecuzione di \func{exec} verrà caricata in
1305 memoria l'immagine del programma eseguito, che a questo punto perde ogni
1306 riferimento ai valori tornati da \func{accept}. Il socket descriptor però
1307 resta aperto, e se si è seguita una opportuna convenzione per rendere noto al
1308 programma eseguito qual è il socket connesso (ad esempio il solito
1309 \cmd{xinetd} fa sempre in modo che i file descriptor 0, 1 e 2 corrispondano al
1310 socket connesso) quest'ultimo potrà usare la funzione \func{getpeername} per
1311 determinare l'indirizzo remoto del client.
1313 Infine è da chiarire (si legga la pagina di manuale) che, come per
1314 \func{accept}, il terzo argomento, che è specificato dallo standard POSIX.1g
1315 come di tipo \code{socklen\_t *} in realtà deve sempre corrispondere ad un
1316 \ctyp{int *} come prima dello standard, perché tutte le realizzazioni dei
1317 socket BSD fanno questa assunzione.
1320 \subsection{La funzione \func{close}}
1321 \label{sec:TCP_func_close}
1323 La funzione standard Unix \func{close} (vedi sez.~\ref{sec:file_open_close})
1324 che si usa sui file può essere usata con lo stesso effetto anche sui file
1325 descriptor associati ad un socket.
1327 L'azione di questa funzione quando applicata a socket è di marcarlo come
1328 chiuso e ritornare immediatamente al processo. Una volta chiamata il socket
1329 descriptor non è più utilizzabile dal processo e non può essere usato come
1330 argomento per una \func{write} o una \func{read} (anche se l'altro capo della
1331 connessione non avesse chiuso la sua parte). Il kernel invierà comunque tutti
1332 i dati che ha in coda prima di iniziare la sequenza di chiusura. Vedremo più
1333 avanti in sez.~\ref{sec:sock_generic_options} come sia possibile cambiare
1334 questo comportamento, e cosa può essere fatto perché il processo possa
1335 assicurarsi che l'altro capo abbia ricevuto tutti i dati.
1337 Come per tutti i file descriptor anche per i socket viene mantenuto un numero
1338 di riferimenti, per cui se più di un processo ha lo stesso socket aperto
1339 l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
1340 fintanto che il numero di riferimenti non si annulla, questo si applica, come
1341 visto in sez.~\ref{sec:file_shared_access}, sia ai file descriptor duplicati
1342 che a quelli ereditati dagli eventuali processi figli, ed è il comportamento
1343 che ci si aspetta in una qualunque applicazione client/server.
1345 Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura
1346 descritta in sez.~\ref{sec:TCP_conn_term}, si può invece usare la funzione
1347 \func{shutdown} su cui torneremo in seguito (vedi
1348 sez.~\ref{sec:TCP_shutdown}).
1351 \section{Un esempio elementare: il servizio \textit{daytime}}
1352 \label{sec:TCP_daytime_application}
1354 Avendo introdotto le funzioni di base per la gestione dei socket, potremo
1355 vedere in questa sezione un primo esempio di applicazione elementare che
1356 realizza il servizio \textit{daytime} su TCP, secondo quanto specificato
1357 dall'\href{http://www.ietf.org/rfc/rfc867.txt}{RFC~867}. Prima di passare
1358 agli esempi del client e del server, inizieremo riesaminando con maggiori
1359 dettagli una peculiarità delle funzioni di I/O, già accennata in
1360 sez.~\ref{sec:file_read} e sez.~\ref{sec:file_write}, che nel caso dei socket
1361 è particolarmente rilevante. Passeremo poi ad illustrare gli esempi della
1362 realizzazione, sia dal lato client, che dal lato server, che si è effettuata
1363 sia in forma iterativa che concorrente.
1366 \subsection{Il comportamento delle funzioni di I/O}
1367 \label{sec:sock_io_behav}
1369 Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
1370 le funzioni di input/output non sempre hanno lo stesso comportamento che
1371 avrebbero con i normali file di dati (in particolare questo accade per i
1372 socket di tipo stream).
1374 Infatti con i socket è comune che funzioni come \func{read} o \func{write}
1375 possano restituire in input o scrivere in output un numero di byte minore di
1376 quello richiesto. Come già accennato in sez.~\ref{sec:file_read} questo è un
1377 comportamento normale per le funzioni di I/O, ma con i normali file di dati il
1378 problema si avverte solo in lettura, quando si incontra la fine del file. In
1379 generale non è così, e con i socket questo è particolarmente evidente.
1382 \begin{figure}[!htbp]
1383 \footnotesize \centering
1384 \begin{minipage}[c]{\codesamplewidth}
1385 \includecodesample{listati/FullRead.c}
1388 \caption{La funzione \func{FullRead}, che legge esattamente \var{count} byte
1389 da un file descriptor, iterando opportunamente le letture.}
1390 \label{fig:sock_FullRead_code}
1393 Quando ci si trova ad affrontare questo comportamento tutto quello che si deve
1394 fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di
1395 byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non
1396 sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
1397 \const{PIPE\_BUF} byte in una \textit{pipe} (si riveda quanto detto in
1398 sez.~\ref{sec:ipc_pipes}).
1400 Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono
1401 definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono
1402 lettura e scrittura tenendo conto di questa caratteristica, ed in grado di
1403 ritornare solo dopo avere letto o scritto esattamente il numero di byte
1404 specificato; il sorgente è riportato rispettivamente in
1405 fig.~\ref{fig:sock_FullRead_code} e fig.~\ref{fig:sock_FullWrite_code} ed è
1406 disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
1409 \begin{figure}[!htbp]
1411 \footnotesize \centering
1412 \begin{minipage}[c]{\codesamplewidth}
1413 \includecodesample{listati/FullWrite.c}
1416 \caption{La funzione \func{FullWrite}, che scrive esattamente \var{count}
1417 byte su un file descriptor, iterando opportunamente le scritture.}
1418 \label{fig:sock_FullWrite_code}
1421 Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo
1422 fino all'esaurimento del numero di byte richiesti, in caso di errore viene
1423 controllato se questo è \errcode{EINTR} (cioè un'interruzione della
1424 \textit{system call} dovuta ad un segnale), nel qual caso l'accesso viene
1425 ripetuto, altrimenti l'errore viene ritornato al programma chiamante,
1426 interrompendo il ciclo.
1428 Nel caso della lettura, se il numero di byte letti è zero, significa che si è
1429 arrivati alla fine del file (per i socket questo significa in genere che
1430 l'altro capo è stato chiuso, e quindi non sarà più possibile leggere niente) e
1431 pertanto si ritorna senza aver concluso la lettura di tutti i byte
1432 richiesti. Entrambe le funzioni restituiscono 0 in caso di successo, ed un
1433 valore negativo in caso di errore, \func{FullRead} restituisce il numero di
1434 byte non letti in caso di \textit{end-of-file} prematuro.
1437 \subsection{Il client \textit{daytime}}
1438 \label{sec:TCP_daytime_client}
1440 Il primo esempio di applicazione delle funzioni di base illustrate in
1441 sez.~\ref{sec:TCP_functions} è relativo alla creazione di un client elementare
1442 per il servizio \textit{daytime}, un servizio elementare, definito
1443 nell'\href{http://www.ietf.org/rfc/rfc867.txt}{RFC~867}, che restituisce
1444 l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
1447 In fig.~\ref{fig:TCP_daytime_client_code} è riportata la sezione principale
1448 del codice del nostro client. Il sorgente completo del programma
1449 (\texttt{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una
1450 funzione per stampare un messaggio di aiuto) è allegato alla guida nella
1451 sezione dei codici sorgente e può essere compilato su una qualunque macchina
1454 \begin{figure}[!htbp]
1455 \footnotesize \centering
1456 \begin{minipage}[c]{\codesamplewidth}
1457 \includecodesample{listati/TCP_daytime.c}
1460 \caption{Esempio di codice di un client elementare per il servizio
1462 \label{fig:TCP_daytime_client_code}
1465 Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari;
1466 dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
1467 tutta la parte relativa al trattamento degli argomenti passati dalla linea di
1468 comando (effettuata con le apposite funzioni illustrate in
1469 sez.~\ref{sec:proc_opt_handling}).
1471 Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo
1472 \const{SOCK\_STREAM} e di famiglia \const{AF\_INET}). La funzione
1473 \func{socket} ritorna il descrittore che viene usato per identificare il
1474 socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
1475 stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce
1476 (\texttt{\small 17}) con un codice di errore.
1478 Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
1479 struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
1480 il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è
1481 inizializzare tutto a zero, per poi inserire il tipo di indirizzo
1482 (\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima
1483 la funzione \func{htons} per convertire il formato dell'intero usato dal
1484 computer a quello usato nella rete, infine (\texttt{\small 23--27}) si può
1485 utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico
1486 passato dalla linea di comando.
1488 A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul
1489 socket creato in precedenza (\texttt{\small 29}) si può stabilire la
1490 connessione con il server. Per questo si deve utilizzare come secondo
1491 argomento la struttura preparata in precedenza con il relativo indirizzo; si
1492 noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast.
1493 Un valore di ritorno della funzione negativo implica il fallimento della
1494 connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si
1495 ritorna (\texttt{\small 31}).
1497 Completata con successo la connessione il passo successivo (\texttt{\small
1498 34--40}) è leggere la data dal socket; il protocollo prevede che il server
1499 invii sempre una stringa alfanumerica, il formato della stringa non è
1500 specificato dallo standard, per cui noi useremo il formato usato dalla
1501 funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè
1504 Wed Apr 4 00:53:00 2001\r\n
1506 questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read}
1507 in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small
1508 35}) con il solito carattere nullo per poter essere stampata (\texttt{\small
1509 36}) sullo \textit{standard output} con l'uso di \func{fputs}.
1511 Come si è già spiegato in sez.~\ref{sec:sock_io_behav} la risposta dal socket
1512 potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel
1513 caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte. Per
1514 questo nel caso generale non si può mai assumere che tutti i dati arrivino con
1515 una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo
1516 in cui si continui a leggere fintanto che la funzione \func{read} non ritorni
1517 uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero
1518 minore di zero (che significa un errore nella connessione).
1520 Si noti come in questo caso la fine dei dati sia specificata dal server che
1521 chiude la connessione (anche questo è quanto richiesto dal protocollo); questa
1522 è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma
1523 ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco
1524 di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed),
1525 mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il
1526 punto essenziale è che TCP non provvede nessuna indicazione che permetta di
1527 marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il
1530 Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene
1531 fornito direttamente dal \textsl{superdemone} \cmd{xinetd}, pertanto basta
1532 assicurarsi che esso sia abilitato nel relativo file di configurazione.}
1533 possiamo verificare il funzionamento del nostro client, avremo allora:
1535 [piccardi@gont sources]$ \textbf{./daytime 127.0.0.1}
1536 Mon Apr 21 20:46:11 2003
1539 e come si vede tutto funziona regolarmente.
1542 \subsection{Un server \textit{daytime} iterativo}
1543 \label{sec:TCP_daytime_iter_server}
1545 Dopo aver illustrato il client daremo anche un esempio di un server
1546 elementare, che sia anche in grado di rispondere al precedente client. Come
1547 primo esempio realizzeremo un server iterativo, in grado di fornire una sola
1548 risposta alla volta. Il codice del programma è nuovamente mostrato in
1549 fig.~\ref{fig:TCP_daytime_iter_server_code}, il sorgente completo
1550 (\texttt{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli
1553 \begin{figure}[!htbp]
1554 \footnotesize \centering
1555 \begin{minipage}[c]{\codesamplewidth}
1556 \includecodesample{listati/TCP_iter_daytimed.c}
1559 \caption{Esempio di codice di un semplice server per il servizio daytime.}
1560 \label{fig:TCP_daytime_iter_server_code}
1563 Come per il client si includono (\texttt{\small 1--9}) gli header necessari a
1564 cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small
1565 14--18}) alcune costanti e le variabili necessarie in seguito. Come nel caso
1566 precedente si sono omesse le parti relative al trattamento delle opzioni da
1569 La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente,
1570 come pure l'inizializzazione (\texttt{\small 25--29}) della struttura
1571 \struct{sockaddr\_in}. Anche in questo caso (\texttt{\small 28}) si usa la
1572 porta standard del servizio \textit{daytime}, ma come indirizzo IP si usa
1573 (\texttt{\small 29}) il valore predefinito \const{INET\_ANY}, che corrisponde
1574 all'indirizzo generico.
1576 Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind}
1577 che permette di associare la precedente struttura al socket, in modo che
1578 quest'ultimo possa essere usato per accettare connessioni su una qualunque
1579 delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small
1580 31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il
1583 Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``\textsl{in
1584 ascolto}'' il socket; questo viene fatto (\texttt{\small 36}) con la
1585 funzione \func{listen} che dice al kernel di accettare connessioni per il
1586 socket che abbiamo creato; la funzione indica inoltre, con il secondo
1587 argomento, il numero massimo di connessioni che il kernel accetterà di mettere
1588 in coda per il suddetto socket. Di nuovo in caso di errore si stampa
1589 (\texttt{\small 37}) un messaggio, e si esce (\texttt{\small 38})
1592 La chiamata a \func{listen} completa la preparazione del socket per l'ascolto
1593 (che viene chiamato anche \textit{listening descriptor}) a questo punto si può
1594 procedere con il ciclo principale (\texttt{\small 40--53}) che viene eseguito
1595 indefinitamente. Il primo passo (\texttt{\small 42}) è porsi in attesa di
1596 connessioni con la chiamata alla funzione \func{accept}, come in precedenza in
1597 caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce
1598 (\texttt{\small 44}).
1600 Il processo resterà in stato di \textit{sleep} fin quando non arriva e viene
1601 accettata una connessione da un client; quando questo avviene \func{accept}
1602 ritorna, restituendo un secondo descrittore, che viene chiamato
1603 \textit{connected descriptor}, e che è quello che verrà usato dalla successiva
1604 chiamata alla \func{write} per scrivere la risposta al client.
1606 Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente
1607 con una chiamata a \texttt{time}, con il quale si potrà opportunamente
1608 costruire (\texttt{\small 47}) la stringa con la data da trasmettere
1609 (\texttt{\small 48}) con la chiamata a \func{write}. Completata la
1610 trasmissione il nuovo socket viene chiuso (\texttt{\small 52}). A questo
1611 punto il ciclo si chiude ricominciando da capo in modo da poter ripetere
1612 l'invio della data in risposta ad una successiva connessione.
1614 È importante notare che questo server è estremamente elementare, infatti, a
1615 parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado
1616 di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un
1617 \textsl{server iterativo}. Inoltre è scritto per essere lanciato da linea di
1618 comando, se lo si volesse utilizzare come demone occorrerebbero le opportune
1619 modifiche (come una chiamata a \func{daemon} prima dell'inizio del ciclo
1620 principale) per tener conto di quanto illustrato in
1621 sez.~\ref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma
1622 di gestione della terminazione del processo, dato che tutti i file descriptor
1623 vengono chiusi automaticamente alla sua uscita, e che, non generando figli,
1624 non è necessario preoccuparsi di gestire la loro terminazione.
1627 \subsection{Un server \textit{daytime} concorrente}
1628 \label{sec:TCP_daytime_cunc_server}
1630 Il server \texttt{daytime} dell'esempio in
1631 sez.~\ref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo,
1632 in cui viene servita una richiesta alla volta; in generale però, specie se il
1633 servizio è più complesso e comporta uno scambio di dati più sostanzioso di
1634 quello in questione, non è opportuno bloccare un server nel servizio di un
1635 client per volta; per questo si ricorre alle capacità di multitasking del
1638 Come spiegato in sez.~\ref{sec:proc_fork} una delle modalità più comuni di
1639 funzionamento da parte dei server è quella di usare la funzione \func{fork}
1640 per creare, ad ogni richiesta da parte di un client, un processo figlio che si
1641 incarichi della gestione della comunicazione. Si è allora riscritto il server
1642 \textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche
1643 una opzione per la stampa degli indirizzi delle connessioni ricevute.
1645 In fig.~\ref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del
1646 codice, in cui si sono tralasciati il trattamento delle opzioni e le parti
1647 rimaste invariate rispetto al precedente esempio (cioè tutta la parte
1648 riguardante l'apertura passiva del socket). Al solito il sorgente completo del
1649 server, nel file \texttt{TCP\_cunc\_daytimed.c}, è allegato insieme ai
1650 sorgenti degli altri esempi.
1652 \begin{figure}[!htbp]
1653 \footnotesize \centering
1654 \begin{minipage}[c]{\codesamplewidth}
1655 \includecodesample{listati/TCP_cunc_daytimed.c}
1658 \caption{Esempio di codice di un server concorrente elementare per il
1660 \label{fig:TCP_daytime_cunc_server_code}
1663 Stavolta (\texttt{\small 21--26}) la funzione \func{accept} è chiamata
1664 fornendo una struttura di indirizzi in cui saranno ritornati l'indirizzo IP e
1665 la porta da cui il client effettua la connessione, che in un secondo tempo,
1666 (\texttt{\small 40--44}), se il logging è abilitato, stamperemo sullo
1667 \textit{standard output}.
1669 Quando \func{accept} ritorna il server chiama la funzione \func{fork}
1670 (\texttt{\small 27--31}) per creare il processo figlio che effettuerà
1671 (\texttt{\small 32--46}) tutte le operazioni relative a quella connessione,
1672 mentre il padre proseguirà l'esecuzione del ciclo principale in attesa di
1673 ulteriori connessioni.
1675 Si noti come il figlio operi solo sul socket connesso, chiudendo
1676 immediatamente (\texttt{\small 33}) il socket \var{list\_fd}; mentre il padre
1677 continua ad operare solo sul socket in ascolto chiudendo (\texttt{\small 48})
1678 \var{conn\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in
1679 sez.~\ref{sec:TCP_func_close} nessuna delle due chiamate a \func{close} causa
1680 l'innesco della sequenza di chiusura perché il numero di riferimenti al file
1681 descriptor non si è annullato.
1683 Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e
1684 lo stesso vale per \var{conn\_fd} dopo il ritorno di \func{accept}, ma dopo la
1685 \func{fork} i descrittori vengono duplicati nel padre e nel figlio per cui
1686 entrambi i socket si trovano con due referenze. Questo fa sì che quando il
1687 padre chiude \var{sock\_fd} esso resta con una referenza da parte del figlio,
1688 e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato
1689 le sue operazioni, chiamerà (\texttt{\small 45}) la funzione \func{close}.
1691 In realtà per il figlio non sarebbe necessaria nessuna chiamata a
1692 \func{close}, in quanto con la \func{exit} finale (\texttt{\small 45}) tutti i
1693 file descriptor, quindi anche quelli associati ai socket, vengono
1694 automaticamente chiusi. Tuttavia si è preferito effettuare esplicitamente le
1695 chiusure per avere una maggiore chiarezza del codice, e per evitare eventuali
1696 errori, prevenendo ad esempio un uso involontario del \textit{listening
1699 Si noti invece come sia essenziale che il padre chiuda ogni volta il socket
1700 connesso dopo la \func{fork}; se così non fosse nessuno di questi socket
1701 sarebbe effettivamente chiuso dato che alla chiusura da parte del figlio
1702 resterebbe ancora un riferimento nel padre. Si avrebbero così due effetti: il
1703 padre potrebbe esaurire i descrittori disponibili (che sono un numero limitato
1704 per ogni processo) e soprattutto nessuna delle connessioni con i client
1707 Come per ogni server iterativo il lavoro di risposta viene eseguito
1708 interamente dal processo figlio. Questo si incarica (\texttt{\small 34}) di
1709 chiamare \func{time} per leggere il tempo corrente, e di stamparlo
1710 (\texttt{\small 35}) sulla stringa contenuta in \var{buffer} con l'uso di
1711 \func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small
1712 36--39}) sul socket, controllando che non ci siano errori. Anche in questo
1713 caso si è evitato il ricorso a \func{FullWrite} in quanto la stringa è
1714 estremamente breve e verrà senz'altro scritta in un singolo segmento.
1716 Inoltre nel caso sia stato abilitato il \textit{logging} delle connessioni, si
1717 provvede anche (\texttt{\small 40--43}) a stampare sullo \textit{standard
1718 output} l'indirizzo e la porta da cui il client ha effettuato la
1719 connessione, usando i valori contenuti nelle strutture restituite da
1720 \func{accept}, eseguendo le opportune conversioni con \func{inet\_ntop} e
1723 Ancora una volta l'esempio è estremamente semplificato, si noti come di nuovo
1724 non si sia gestita né la terminazione del processo né il suo uso come demone,
1725 che tra l'altro sarebbe stato incompatibile con l'uso della opzione di logging
1726 che stampa gli indirizzi delle connessioni sullo standard output. Un altro
1727 aspetto tralasciato è la gestione della terminazione dei processi figli,
1728 torneremo su questo più avanti quando tratteremo alcuni esempi di server più
1732 \section{Un esempio più completo: il servizio \textit{echo}}
1733 \label{sec:TCP_echo_application}
1735 L'esempio precedente, basato sul servizio \textit{daytime}, è un esempio molto
1736 elementare, in cui il flusso dei dati va solo nella direzione dal server al
1737 client. In questa sezione esamineremo un esempio di applicazione client/server
1738 un po' più complessa, che usi i socket TCP per una comunicazione in entrambe
1741 Ci limiteremo a fornire una realizzazione elementare, che usi solo le funzioni
1742 di base viste finora, ma prenderemo in esame, oltre al comportamento in
1743 condizioni normali, anche tutti i possibili scenari particolari (errori,
1744 sconnessione della rete, crash del client o del server durante la connessione)
1745 che possono avere luogo durante l'impiego di un'applicazione di rete, partendo
1746 da una versione primitiva che dovrà essere rimaneggiata di volta in volta per
1747 poter tenere conto di tutte le evenienze che si possono manifestare nella vita
1748 reale di un'applicazione di rete, fino ad arrivare ad una realizzazione
1752 \subsection{Il servizio \textit{echo}}
1753 \label{sec:TCP_echo}
1755 Nella ricerca di un servizio che potesse fare da esempio per una comunicazione
1756 bidirezionale, si è deciso, seguendo la scelta di Stevens in \cite{UNP1}, di
1757 usare il servizio \textit{echo}, che si limita a restituire in uscita quanto
1758 immesso in ingresso. Infatti, nonostante la sua estrema semplicità, questo
1759 servizio costituisce il prototipo ideale per una generica applicazione di rete
1760 in cui un server risponde alle richieste di un client. Nel caso di una
1761 applicazione più complessa quello che si potrà avere in più è una elaborazione
1762 dell'input del client, che in molti casi viene interpretato come un comando,
1763 da parte di un server che risponde fornendo altri dati in uscita.
1765 Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
1766 direttamente dal superserver \cmd{inetd}, ed è definito
1767 dall'\href{http://www.ietf.org/rfc/rfc862.txt}{RFC~862}. Come dice il nome il
1768 servizio deve riscrivere indietro sul socket i dati che gli vengono inviati in
1769 ingresso. L'RFC descrive le specifiche del servizio sia per TCP che UDP, e per
1770 qil primo stabilisce che una volta stabilita la connessione ogni dato in
1771 ingresso deve essere rimandato in uscita fintanto che il chiamante non ha
1772 chiude la connessione. Al servizio è assegnata la porta riservata 7.
1774 Nel nostro caso l'esempio sarà costituito da un client che legge una linea di
1775 caratteri dallo \textit{standard input} e la scrive sul server. A sua volta il
1776 server leggerà la linea dalla connessione e la riscriverà immutata
1777 all'indietro. Sarà compito del client leggere la risposta del server e
1778 stamparla sullo \textit{standard output}.
1781 \subsection{Il client \textit{echo}: prima versione}
1782 \label{sec:TCP_echo_client}
1784 Il codice della prima versione del client per il servizio \textit{echo} (file
1785 \texttt{TCP\_echo\_first.c}) dei sorgenti allegati alla guida) è riportato in
1786 fig.~\ref{fig:TCP_echo_client_1}. Esso ricalca la struttura del precedente
1787 client per il servizio \textit{daytime} (vedi
1788 sez.~\ref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27})
1789 è sostanzialmente identica, a parte l'uso di una porta diversa.
1791 \begin{figure}[!htb]
1792 \footnotesize \centering
1793 \begin{minipage}[c]{\codesamplewidth}
1794 \includecodesample{listati/TCP_echo_first.c}
1797 \caption{Codice della prima versione del client \textit{echo}.}
1798 \label{fig:TCP_echo_client_1}
1801 Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a
1802 riga di comando. Una volta dichiarate le variabili, si prosegue
1803 (\texttt{\small 10--13}) con la creazione del socket con l'usuale controllo
1804 degli errori, alla preparazione (\texttt{\small 14--17}) della struttura
1805 dell'indirizzo, che stavolta usa la porta 7 riservata al servizio
1806 \textit{echo}, infine si converte (\texttt{\small 18--22}) l'indirizzo
1807 specificato a riga di comando. A questo punto (\texttt{\small 23--27}) si può
1808 eseguire la connessione al server secondo la stessa modalità usata in
1809 sez.~\ref{sec:TCP_daytime_client}.
1811 Completata la connessione, per gestire il funzionamento del protocollo si usa
1812 la funzione \code{ClientEcho}, il cui codice si è riportato a parte in
1813 fig.~\ref{fig:TCP_client_echo_sub}. Questa si preoccupa di gestire tutta la
1814 comunicazione, leggendo una riga alla volta dallo \textit{standard input}
1815 \file{stdin}, scrivendola sul socket e ristampando su \file{stdout} quanto
1816 ricevuto in risposta dal server. Al ritorno dalla funzione (\texttt{\small
1817 30--31}) anche il programma termina.
1819 La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per
1820 gestire i dati inviati e letti sul socket. La comunicazione viene gestita
1821 all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla
1822 connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets},
1823 che legge una linea di testo (terminata da un \texttt{CR} e fino al massimo di
1824 \const{MAXLINE} caratteri) e la salva sul buffer di invio.
1826 Si usa poi (\texttt{\small 6}) la funzione \func{FullWrite}, vista in
1827 sez.~\ref{sec:sock_io_behav}, per scrivere i dati sul socket, gestendo
1828 automaticamente l'invio multiplo qualora una singola \func{write} non sia
1829 sufficiente. I dati vengono riletti indietro (\texttt{\small 7}) con una
1830 \func{read}\footnote{si è fatta l'assunzione implicita che i dati siano
1831 contenuti tutti in un solo segmento, così che la chiamata a \func{read} li
1832 restituisca sempre tutti; avendo scelto una dimensione ridotta per il buffer
1833 questo sarà sempre vero, vedremo più avanti come superare il problema di
1834 rileggere indietro tutti e soli i dati disponibili, senza bloccarsi.} sul
1835 buffer di ricezione e viene inserita (\texttt{\small 8}) la terminazione della
1836 stringa e per poter usare (\texttt{\small 9}) la funzione \func{fputs} per
1837 scriverli su \file{stdout}.
1839 \begin{figure}[!htbp]
1840 \footnotesize \centering
1841 \begin{minipage}[c]{\codesamplewidth}
1842 \includecodesample{listati/ClientEcho_first.c}
1845 \caption{Codice della prima versione della funzione \texttt{ClientEcho} per
1846 la gestione del servizio \textit{echo}.}
1847 \label{fig:TCP_client_echo_sub}
1850 Quando si concluderà l'invio di dati mandando un \textit{end-of-file} sullo
1851 \textit{standard input} si avrà il ritorno di \func{fgets} con un puntatore
1852 nullo (si riveda quanto spiegato in sez.~\ref{sec:file_unformatted_io}) e la
1853 conseguente uscita dal ciclo; al che la subroutine ritorna ed il nostro
1854 programma client termina.
1856 Si può effettuare una verifica del funzionamento del client abilitando il
1857 servizio \textit{echo} nella configurazione di \cmd{xinetd} sulla propria
1858 macchina ed usandolo direttamente verso di esso in locale, vedremo in
1859 dettaglio più avanti (in sez.~\ref{sec:TCP_echo_startup}) il funzionamento del
1860 programma, usato però con la nostra versione del server \textit{echo}, che
1861 illustriamo immediatamente.
1864 \subsection{Il server \textit{echo}: prima versione}
1865 \label{sec:TCPsimp_server_main}
1867 La prima versione del server, contenuta nel file \texttt{TCP\_echod\_first.c},
1868 è riportata in fig.~\ref{fig:TCP_echo_server_first_code} e
1869 fig.~\ref{fig:TCP_echo_server_first_main}. Come abbiamo fatto per il client
1870 anche il server è stato diviso in un corpo principale, costituito dalla
1871 funzione \code{main}, che è molto simile a quello visto nel precedente esempio
1872 per il server del servizio \textit{daytime} di
1873 sez.~\ref{sec:TCP_daytime_cunc_server}, e da una funzione ausiliaria
1874 \code{ServEcho} che si cura della gestione del servizio.
1876 \begin{figure}[!htb]
1877 \footnotesize \centering
1878 \begin{minipage}[c]{\codesamplewidth}
1879 \includecodesample{listati/TCP_echod_first_init.c}
1882 \caption{Codice di inizializzatione della prima versione del server
1883 per il servizio \textit{echo}.}
1884 \label{fig:TCP_echo_server_first_code}
1887 In questo caso però, rispetto a quanto visto nell'esempio di
1888 fig.~\ref{fig:TCP_daytime_cunc_server_code} si è preferito scrivere il server
1889 curando maggiormente alcuni dettagli, per tenere conto anche di alcune
1890 esigenze generali (che non riguardano direttamente la rete), come la
1891 possibilità di lanciare il server anche in modalità interattiva e la cessione
1892 dei privilegi di amministratore non appena questi non sono più necessari.
1894 La sezione iniziale del programma (\texttt{\small 8--21}) è la stessa del
1895 server di sez.~\ref{sec:TCP_daytime_cunc_server}, ed ivi descritta in
1896 dettaglio: crea il socket, inizializza l'indirizzo e esegue \func{bind}; dato
1897 che quest'ultima funzione viene usata su una porta riservata, il server dovrà
1898 essere eseguito da un processo con i privilegi di amministratore, pena il
1899 fallimento della chiamata.
1901 Una volta eseguita la funzione \func{bind} però i privilegi di amministratore
1902 non sono più necessari, per questo è sempre opportuno rilasciarli, in modo da
1903 evitare problemi in caso di eventuali vulnerabilità del server. Per questo
1904 prima (\texttt{\small 22--26}) si esegue \func{setgid} per assegnare il
1905 processo ad un gruppo senza privilegi,\footnote{si è usato il valore 65534,
1906 ovvero -1 per il formato \ctyp{short}, che di norma in tutte le
1907 distribuzioni viene usato per identificare il gruppo \texttt{nogroup} e
1908 l'utente \texttt{nobody}, usati appunto per eseguire programmi che non
1909 richiedono nessun privilegio particolare.} e poi si ripete (\texttt{\small
1910 27--30}) l'operazione usando \func{setuid} per cambiare anche
1911 l'utente.\footnote{si tenga presente che l'ordine in cui si eseguono queste
1912 due operazioni è importante, infatti solo avendo i privilegi di
1913 amministratore si può cambiare il gruppo di un processo ad un altro di cui
1914 non si fa parte, per cui chiamare prima \func{setuid} farebbe fallire una
1915 successiva chiamata a \func{setgid}. Inoltre si ricordi (si riveda quanto
1916 esposto in sez.~\ref{sec:proc_perms}) che usando queste due funzioni il
1917 rilascio dei privilegi è irreversibile.} Infine (\texttt{\small 30--36}),
1918 qualora sia impostata la variabile \var{demonize}, prima (\texttt{\small 31})
1919 si apre il sistema di logging per la stampa degli errori, e poi
1920 (\texttt{\small 32--35}) si invoca \func{daemon} per eseguire in background il
1921 processo come demone.
1924 \begin{figure}[!htb]
1925 \footnotesize \centering
1926 \begin{minipage}[c]{\codesamplewidth}
1927 \includecodesample{listati/TCP_echod_first_main.c}
1930 \caption{Codice di inizializzatione della prima versione del server
1931 per il servizio \textit{echo}.}
1932 \label{fig:TCP_echo_server_first_main}
1935 A questo punto il programma prosegue nel ciclo principale, illustrato in
1936 fig.~\ref{fig:TCP_echo_server_first_main}, usando lo schema già visto in
1937 precedenza per server per il servizio \textit{daytime}, con l'unica differenza
1938 della chiamata alla funzione \code{PrintErr}, riportata in
1939 fig.~\ref{fig:TCP_PrintErr}, al posto di \func{perror} per la stampa degli
1942 Si inizia con il porre (\texttt{\small 3--6}) in ascolto il socket, e poi si
1943 esegue indefinitamente il ciclo principale (\texttt{\small 7--26}).
1944 All'interno di questo si ricevono (\texttt{\small 9--12}) le connessioni,
1945 creando (\texttt{\small 13--16}) un processo figlio per ciascuna di esse.
1946 Quest'ultimo (\texttt{\small 17--21}), chiuso (\texttt{\small 18}) il
1947 \textit{listening socket}, esegue (\texttt{\small 19}) la funzione di gestione
1948 del servizio \code{ServEcho}, ed al ritorno di questa esce (\texttt{\small
1951 Il padre invece si limita (\texttt{\small 22}) a chiudere il \textit{connected
1952 socket} per ricominciare da capo il ciclo in attesa di nuove connessioni. In
1953 questo modo si ha un server concorrente. La terminazione del padre non è
1954 gestita esplicitamente, e deve essere effettuata inviando un segnale al
1957 Avendo trattato direttamente la gestione del programma come demone, si è
1958 dovuto anche provvedere alla necessità di poter stampare eventuali messaggi di
1959 errore attraverso il sistema del \textit{syslog} trattato in
1960 sez.~\ref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando
1961 come \textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato
1962 in fig.~\ref{fig:TCP_PrintErr}.
1964 \begin{figure}[!htb]
1965 \footnotesize \centering
1966 \begin{minipage}[c]{\codesamplewidth}
1967 \includecodesample{listati/PrintErr.c}
1970 \caption{Codice della funzione \code{PrintErr} per la generalizzazione della
1971 stampa degli errori sullo \textit{standard input} o attraverso il
1973 \label{fig:TCP_PrintErr}
1977 In essa ci si limita a controllare (\texttt{\small 2}) se è stato impostato
1978 (valore attivo per default) l'uso come demone, nel qual caso (\texttt{\small
1979 3}) si usa \func{syslog} (vedi sez.~\ref{sec:sess_daemon}) per stampare il
1980 messaggio di errore fornito come argomento sui log di sistema. Se invece si è
1981 in modalità interattiva (attivabile con l'opzione \texttt{-i}) si usa
1982 (\texttt{\small 5}) semplicemente la funzione \func{perror} per stampare sullo
1983 \textit{standard error}.
1985 La gestione del servizio \textit{echo} viene effettuata interamente nella
1986 funzione \code{ServEcho}, il cui codice è mostrato in
1987 fig.~\ref{fig:TCP_ServEcho_first}, e la comunicazione viene gestita all'interno
1988 di un ciclo (\texttt{\small 6--13}). I dati inviati dal client vengono letti
1989 (\texttt{\small 6}) dal socket con una semplice \func{read}, di cui non si
1990 controlla lo stato di uscita, assumendo che ritorni solo in presenza di dati
1993 La riscrittura (\texttt{\small 7}) viene invece gestita dalla funzione
1994 \func{FullWrite} (descritta in fig.~\ref{fig:sock_FullWrite_code}) che si
1995 incarica di tenere conto automaticamente della possibilità che non tutti i
1996 dati di cui è richiesta la scrittura vengano trasmessi con una singola
1999 \begin{figure}[!htb]
2000 \footnotesize \centering
2001 \begin{minipage}[c]{\codesamplewidth}
2002 \includecodesample{listati/ServEcho_first.c}
2005 \caption{Codice della prima versione della funzione \code{ServEcho} per la
2006 gestione del servizio \textit{echo}.}
2007 \label{fig:TCP_ServEcho_first}
2010 In caso di errore di scrittura (si ricordi che \func{FullWrite} restituisce un
2011 valore nullo in caso di successo) si provvede (\texttt{\small 8--10}) a
2012 stampare il relativo messaggio con \func{PrintErr}. Quando il client chiude
2013 la connessione il ricevimento del segmento FIN fa ritornare la \func{read} con
2014 un numero di byte letti pari a zero, il che causa l'uscita dal ciclo e il
2015 ritorno (\texttt{\small 12}) della funzione, che a sua volta causa la
2016 terminazione del processo figlio.
2019 \subsection{L'avvio e il funzionamento ordinario}
2020 \label{sec:TCP_echo_startup}
2022 Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà
2023 di considerare in dettaglio le varie problematiche che si possono incontrare
2024 nello scrivere un'applicazione di rete. Infatti attraverso l'esame delle sue
2025 modalità di funzionamento ordinarie, all'avvio e alla terminazione, e di
2026 quello che avviene nelle varie situazioni limite, da una parte potremo
2027 approfondire la comprensione del protocollo TCP/IP e dall'altra ricavare le
2028 indicazioni necessarie per essere in grado di scrivere applicazioni robuste,
2029 in grado di gestire anche i casi limite.
2031 Il primo passo è compilare e lanciare il server (usando l'utente di
2032 amministrazione, per poter usare la porta 7 che è riservata). All'avvio esso
2033 eseguirà l'apertura passiva con la sequenza delle chiamate a \func{socket},
2034 \func{bind}, \func{listen} e poi si bloccherà nella \func{accept}. A questo
2035 punto si potrà controllarne lo stato con \cmd{netstat}:
2037 [piccardi@roke piccardi]$ \textbf{netstat -at}
2038 Active Internet connections (servers and established)
2039 Proto Recv-Q Send-Q Local Address Foreign Address State
2041 tcp 0 0 *:echo *:* LISTEN
2045 che ci mostra come il socket sia in ascolto sulla porta richiesta, accettando
2046 connessioni da qualunque indirizzo e da qualunque porta e su qualunque
2049 A questo punto si può lanciare il client, esso chiamerà \func{socket} e
2050 \func{connect}; una volta completato il \textit{three way handshake} la
2051 connessione è stabilita; la \func{connect} ritornerà nel client\footnote{si
2052 noti che è sempre la \func{connect} del client a ritornare per prima, in
2053 quanto questo avviene alla ricezione del secondo segmento (l'ACK del server)
2054 del \textit{three way handshake}, la \func{accept} del server ritorna solo
2055 dopo un altro mezzo RTT quando il terzo segmento (l'ACK del client) viene
2056 ricevuto.} e la \func{accept} nel server, ed usando di nuovo \cmd{netstat}
2059 Active Internet connections (servers and established)
2060 Proto Recv-Q Send-Q Local Address Foreign Address State
2061 tcp 0 0 *:echo *:* LISTEN
2062 tcp 0 0 roke:echo gont:32981 ESTABLISHED
2064 mentre per quanto riguarda l'esecuzione dei programmi avremo che:
2066 \item il client chiama la funzione \code{ClientEcho} che si blocca sulla
2067 \func{fgets} dato che non si è ancora scritto nulla sul terminale.
2068 \item il server eseguirà una \func{fork} facendo chiamare al processo figlio
2069 la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read}
2070 dal socket sul quale ancora non sono presenti dati.
2071 \item il processo padre del server chiamerà di nuovo \func{accept}
2072 bloccandosi fino all'arrivo di un'altra connessione.
2074 e se usiamo il comando \cmd{ps} per esaminare lo stato dei processi otterremo
2075 un risultato del tipo:
2077 [piccardi@roke piccardi]$ \textbf{ps ax}
2078 PID TTY STAT TIME COMMAND
2080 2356 pts/0 S 0:00 ./echod
2081 2358 pts/1 S 0:00 ./echo 127.0.0.1
2082 2359 pts/0 S 0:00 ./echod
2085 (dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di
2086 tre processi, tutti in stato di \textit{sleep} (vedi
2087 tab.~\ref{tab:proc_proc_states}).
2089 Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso
2090 niente fintanto che non si preme il tasto di a capo (si ricordi quanto detto
2091 in sez.~\ref{sec:file_unformatted_io} a proposito dell'I/O su terminale).
2092 Solo allora \func{fgets} ritornerà ed il client scriverà quanto immesso dal
2093 terminale sul socket, per poi passare a rileggere quanto gli viene inviato
2094 all'indietro dal server, che a sua volta sarà inviato sullo \textit{standard
2095 output}, che nel caso ne provoca l'immediata stampa a video.
2098 \subsection{La conclusione normale}
2099 \label{sec:TCP_echo_conclusion}
2101 Tutto quello che scriveremo sul client sarà rimandato indietro dal server e
2102 ristampato a video fintanto che non concluderemo l'immissione dei dati; una
2103 sessione tipica sarà allora del tipo:
2105 [piccardi@roke sources]$ \textbf{./echo 127.0.0.1}
2112 che termineremo inviando un EOF dal terminale (usando la combinazione di tasti
2113 ctrl-D, che non compare a schermo); se eseguiamo un \cmd{netstat} a questo
2116 [piccardi@roke piccardi]$ \textbf{netstat -at}
2117 tcp 0 0 *:echo *:* LISTEN
2118 tcp 0 0 localhost:33032 localhost:echo TIME_WAIT
2121 con il client che entra in \texttt{TIME\_WAIT}.
2123 Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
2124 terminazione normale della connessione, che ci servirà poi da riferimento
2125 quando affronteremo il comportamento in caso di conclusioni anomale:
2128 \item inviando un carattere di EOF da terminale la \func{fgets} ritorna
2129 restituendo un puntatore nullo che causa l'uscita dal ciclo di \code{while},
2130 così la funzione \code{ClientEcho} ritorna.
2131 \item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e
2132 come parte del processo di terminazione tutti i file descriptor vengono chiusi
2133 (si ricordi quanto detto in sez.~\ref{sec:proc_term_conclusion}); questo
2134 causa la chiusura del socket di comunicazione; il client allora invierà un
2135 FIN al server a cui questo risponderà con un ACK. A questo punto il client
2136 verrà a trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato
2137 \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in
2138 sez.~\ref{sec:TCP_conn_term}).
2139 \item quando il server riceve il FIN la \func{read} del processo figlio che
2140 gestisce la connessione ritorna restituendo 0 causando così l'uscita dal
2141 ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio
2142 termina chiamando \func{exit}.
2143 \item all'uscita del figlio tutti i file descriptor vengono chiusi, la
2144 chiusura del socket connesso fa sì che venga effettuata la sequenza finale
2145 di chiusura della connessione, viene emesso un FIN dal server che riceverà
2146 un ACK dal client, a questo punto la connessione è conclusa e il client
2147 resta nello stato \texttt{TIME\_WAIT}.
2151 \subsection{La gestione dei processi figli}
2152 \label{sec:TCP_child_hand}
2154 Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
2155 del procedimento di chiusura del processo figlio nel server (si veda quanto
2156 esaminato in sez.~\ref{sec:proc_termination}). In questo caso avremo l'invio
2157 del segnale \signal{SIGCHLD} al padre, ma dato che non si è installato un
2158 gestore e che l'azione predefinita per questo segnale è quella di essere
2159 ignorato, non avendo predisposto la ricezione dello stato di terminazione,
2160 otterremo che il processo figlio entrerà nello stato di \textit{zombie} (si
2161 riveda quanto illustrato in sez.~\ref{sec:sig_sigchld}), come risulterà
2162 ripetendo il comando \cmd{ps}:
2164 2356 pts/0 S 0:00 ./echod
2165 2359 pts/0 Z 0:00 [echod <defunct>]
2168 Dato che non è il caso di lasciare processi \textit{zombie}, occorrerà
2169 ricevere opportunamente lo stato di terminazione del processo (si veda
2170 sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \signal{SIGCHLD}
2171 secondo quanto illustrato in sez.~\ref{sec:sig_sigchld}. Una prima modifica al
2172 nostro server è pertanto quella di inserire la gestione della terminazione dei
2173 processi figli attraverso l'uso di un gestore. Per questo useremo la funzione
2174 \code{Signal} (che abbiamo illustrato in fig.~\ref{fig:sig_Signal_code}), per
2175 installare il gestore che riceve i segnali dei processi figli terminati già
2176 visto in fig.~\ref{fig:sig_sigchld_handl}. Basterà allora aggiungere il
2177 seguente codice: \includecodesnip{listati/sigchildhand.c}
2179 all'esempio illustrato in fig.~\ref{fig:TCP_echo_server_first_code}.
2181 In questo modo però si introduce un altro problema. Si ricordi infatti che,
2182 come spiegato in sez.~\ref{sec:sig_gen_beha}, quando un programma si trova in
2183 stato di \texttt{sleep} durante l'esecuzione di una \textit{system call},
2184 questa viene interrotta alla ricezione di un segnale. Per questo motivo, alla
2185 fine dell'esecuzione del gestore del segnale, se questo ritorna, il programma
2186 riprenderà l'esecuzione ritornando dalla \textit{system call} interrotta con
2187 un errore di \errcode{EINTR}.
2189 Vediamo allora cosa comporta tutto questo nel nostro caso: quando si chiude il
2190 client, il processo figlio che gestisce la connessione terminerà, ed il padre,
2191 per evitare la creazione di \textit{zombie}, riceverà il segnale
2192 \signal{SIGCHLD} eseguendo il relativo gestore. Al ritorno del gestore però
2193 l'esecuzione nel padre ripartirà subito con il ritorno della funzione
2194 \func{accept} (a meno di un caso fortuito in cui il segnale arriva durante
2195 l'esecuzione del programma in risposta ad una connessione) con un errore di
2196 \errcode{EINTR}. Non avendo previsto questa eventualità il programma considera
2197 questo un errore fatale terminando a sua volta con un messaggio del tipo:
2199 [root@gont sources]# \textbf{./echod -i}
2200 accept error: Interrupted system call
2203 Come accennato in sez.~\ref{sec:sig_gen_beha} le conseguenze di questo
2204 comportamento delle \textit{system call} possono essere superate in due modi
2205 diversi, il più semplice è quello di modificare il codice di \func{Signal} per
2206 richiedere il riavvio automatico delle \textit{system call} interrotte secondo
2207 la semantica di BSD, usando l'opzione \const{SA\_RESTART} di \func{sigaction};
2208 rispetto a quanto visto in fig.~\ref{fig:sig_Signal_code}. Definiremo allora
2209 la nuova funzione \func{SignalRestart}\footnote{anche questa è definita,
2210 insieme alle altre funzioni riguardanti la gestione dei segnali, nel file
2211 \file{SigHand.c}, il cui contento completo può essere trovato negli esempi
2212 allegati.} come mostrato in fig.~\ref{fig:sig_SignalRestart_code}, ed
2213 installeremo il gestore usando quest'ultima.
2215 \begin{figure}[!htbp]
2216 \footnotesize \centering
2217 \begin{minipage}[c]{\codesamplewidth}
2218 \includecodesample{listati/SignalRestart.c}
2221 \caption{La funzione \func{SignalRestart}, che installa un gestore di
2222 segnali in semantica BSD per il riavvio automatico delle \textit{system
2224 \label{fig:sig_SignalRestart_code}
2227 Come si può notare questa funzione è identica alla precedente \func{Signal},
2228 illustrata in fig.~\ref{fig:sig_Signal_code}, solo che in questo caso invece
2229 di inizializzare a zero il campo \var{sa\_flags} di \struct{sigaction}, lo si
2230 inizializza (\texttt{\small 5}) al valore \const{SA\_RESTART}. Usando questa
2231 funzione al posto di \func{Signal} nel server non è necessaria nessuna altra
2232 modifica: le \textit{system call} interrotte saranno automaticamente
2233 riavviate, e l'errore \errcode{EINTR} non si manifesterà più.
2235 La seconda soluzione è più invasiva e richiede di controllare tutte le volte
2236 l'errore restituito dalle varie \textit{system call}, ripetendo la chiamata
2237 qualora questo corrisponda ad \errcode{EINTR}. Questa soluzione ha però il
2238 pregio della portabilità, infatti lo standard POSIX dice che la funzionalità
2239 di riavvio automatico delle \textit{system call}, fornita da
2240 \const{SA\_RESTART}, è opzionale, per cui non è detto che essa sia disponibile
2241 su qualunque sistema. Inoltre in certi casi,\footnote{Stevens in \cite{UNP1}
2242 accenna che la maggior parte degli Unix derivati da BSD non fanno ripartire
2243 \func{select}; altri non riavviano neanche \func{accept} e \func{recvfrom},
2244 cosa che invece nel caso di Linux viene sempre fatta.} anche quando questa è
2245 presente, non è detto possa essere usata con \func{accept}.
2247 La portabilità nella gestione dei segnali però viene al costo di una
2248 riscrittura parziale del server, la nuova versione di questo, in cui si sono
2249 introdotte una serie di nuove opzioni che ci saranno utili per il debug, è
2250 mostrata in fig.~\ref{fig:TCP_echo_server_code_second}, dove si sono riportate
2251 la sezioni di codice modificate nella seconda versione del programma, il
2252 codice completo di quest'ultimo si trova nel file
2253 \texttt{TCP\_echod\_second.c} dei sorgenti allegati alla guida.
2255 La prima modifica effettuata è stata quella di introdurre una nuova opzione a
2256 riga di comando, \texttt{-c}, che permette di richiedere il comportamento
2257 compatibile nella gestione di \signal{SIGCHLD} al posto della semantica BSD
2258 impostando la variabile \var{compat} ad un valore non nullo. Questa è
2259 preimpostata al valore nullo, cosicché se non si usa questa opzione il
2260 comportamento di default del server è di usare la semantica BSD.
2262 Una seconda opzione aggiunta è quella di inserire un tempo di attesa fisso
2263 specificato in secondi fra il ritorno della funzione \func{listen} e la
2264 chiamata di \func{accept}, specificabile con l'opzione \texttt{-w}, che
2265 permette di impostare la variabile \var{waiting}. Infine si è introdotta una
2266 opzione \texttt{-d} per abilitare il debugging che imposta ad un valore non
2267 nullo la variabile \var{debugging}. Al solito si è omessa da
2268 fig.~\ref{fig:TCP_echo_server_code_second} la sezione di codice relativa alla
2269 gestione di tutte queste opzioni, che può essere trovata nel sorgente del
2272 \begin{figure}[!htb ]
2273 \footnotesize \centering
2274 \begin{minipage}[c]{\codesamplewidth}
2275 \includecodesample{listati/TCP_echod_second.c}
2278 \caption{La sezione nel codice della seconda versione del server
2279 per il servizio \textit{echo} modificata per tener conto dell'interruzione
2280 delle \textit{system call}.}
2281 \label{fig:TCP_echo_server_code_second}
2284 Vediamo allora come è cambiato il nostro server; una volta definite le
2285 variabili e trattate le opzioni il primo passo (\texttt{\small 9--13}) è
2286 verificare la semantica scelta per la gestione di \signal{SIGCHLD}, a seconda
2287 del valore di \var{compat} (\texttt{\small 9}) si installa il gestore con la
2288 funzione \func{Signal} (\texttt{\small 10}) o con \texttt{SignalRestart}
2289 (\texttt{\small 12}), essendo quest'ultimo il valore di default.
2291 Tutta la sezione seguente, che crea il socket, cede i privilegi di
2292 amministratore ed eventualmente lancia il programma come demone, è rimasta
2293 invariata e pertanto è stata omessa in
2294 fig.~\ref{fig:TCP_echo_server_code_second}; l'unica modifica effettuata prima
2295 dell'entrata nel ciclo principale è stata quella di aver introdotto, subito
2296 dopo la chiamata (\texttt{\small 17--20}) alla funzione \func{listen}, una
2297 eventuale pausa con una condizione (\texttt{\small 21}) sulla variabile
2298 \var{waiting}, che viene inizializzata, con l'opzione \texttt{-w Nsec}, al
2299 numero di secondi da aspettare (il valore preimpostato è nullo).
2301 Si è potuto lasciare inalterata tutta la sezione di creazione del socket
2302 perché nel server l'unica chiamata ad una \textit{system call} lenta, che può
2303 essere interrotta dall'arrivo di \signal{SIGCHLD}, è quella ad \func{accept},
2304 che è l'unica funzione che può mettere il processo padre in stato di sleep nel
2305 periodo in cui un figlio può terminare; si noti infatti come le altre
2306 \textit{system call} lente (si ricordi la distinzione fatta in
2307 sez.~\ref{sec:sig_gen_beha}) o sono chiamate prima di entrare nel ciclo
2308 principale, quando ancora non esistono processi figli, o sono chiamate dai
2309 figli stessi e non risentono di \signal{SIGCHLD}.
2311 Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small
2312 23--42}), rispetto precedente versione di fig.~\ref{fig:TCP_ServEcho_first},
2313 è nella sezione (\texttt{\small 25--31}) in cui si effettua la chiamata di
2314 \func{accept}. Quest'ultima viene effettuata (\texttt{\small 26--27})
2315 all'interno di un ciclo di \code{while}\footnote{la sintassi del C relativa a
2316 questo ciclo può non essere del tutto chiara. In questo caso infatti si è
2317 usato un ciclo vuoto che non esegue nessuna istruzione, in questo modo
2318 quello che viene ripetuto con il ciclo è soltanto il codice che esprime la
2319 condizione all'interno del \code{while}.} che la ripete indefinitamente
2320 qualora in caso di errore il valore di \var{errno} sia \errcode{EINTR}. Negli
2321 altri casi si esce in caso di errore effettivo (\texttt{\small 27--29}),
2322 altrimenti il programma prosegue.
2324 \begin{figure}[!htb]
2325 \footnotesize \centering
2326 \begin{minipage}[c]{\codesamplewidth}
2327 \includecodesample{listati/ServEcho_second.c}
2330 \caption{Codice della seconda versione della funzione \code{ServEcho} per la
2331 gestione del servizio \textit{echo}.}
2332 \label{fig:TCP_ServEcho_second}
2335 Si noti che in questa nuova versione si è aggiunta una ulteriore sezione
2336 (\texttt{\small 32--40}) di aiuto per il debug del programma, che eseguita con
2337 un controllo (\texttt{\small 33}) sul valore della variabile \var{debugging}
2338 impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come
2339 preimpostato, non accade nulla, altrimenti (\texttt{\small 33}) l'indirizzo
2340 ricevuto da \var{accept} viene convertito in una stringa che poi
2341 (\texttt{\small 34--39}) viene opportunamente stampata o sullo schermo o nei
2344 Infine come ulteriore miglioria si è perfezionata la funzione \code{ServEcho},
2345 sia per tenere conto della nuova funzionalità di debugging, che per effettuare
2346 un controllo in caso di errore; il codice della nuova versione è mostrato in
2347 fig.~\ref{fig:TCP_ServEcho_second}.
2349 Rispetto alla precedente versione di fig.~\ref{fig:TCP_ServEcho_first} in
2350 questo caso si è provveduto a controllare (\texttt{\small 7--10}) il valore di
2351 ritorno di \func{read} per rilevare un eventuale errore, in modo da stampare
2352 (\texttt{\small 8}) un messaggio di errore e ritornare (\texttt{\small 9})
2353 concludendo la connessione.
2355 Inoltre qualora sia stata attivata la funzionalità di debug (avvalorando
2356 \var{debugging} tramite l'apposita opzione \texttt{-d}) si provvederà a
2357 stampare (\texttt{\small 16--24}) il numero di byte e la stringa letta dal
2358 client, tenendo conto della modalità di invocazione del server, se interattiva
2359 o in forma di demone.
2362 \section{I vari scenari critici}
2363 \label{sec:TCP_echo_critical}
2365 Con le modifiche viste in sez.~\ref{sec:TCP_child_hand} il nostro esempio
2366 diventa in grado di affrontare la gestione ordinaria delle connessioni, ma un
2367 server di rete deve tenere conto che, al contrario di quanto avviene per i
2368 server che operano nei confronti di processi presenti sulla stessa macchina,
2369 la rete è di sua natura inaffidabile, per cui è necessario essere in grado di
2370 gestire tutta una serie di situazioni critiche che non esistono per i processi
2374 \subsection{La terminazione precoce della connessione}
2375 \label{sec:TCP_conn_early_abort}
2377 La prima situazione critica è quella della terminazione precoce, causata da un
2378 qualche errore sulla rete, della connessione effettuata da un client. Come
2379 accennato in sez.~\ref{sec:TCP_func_accept} la funzione \func{accept} riporta
2380 tutti gli eventuali errori di rete pendenti su una connessione sul
2381 \textit{connected socket}. Di norma questo non è un problema, in quanto non
2382 appena completata la connessione, \func{accept} ritorna, e l'errore sarà
2383 rilevato in seguito dal processo che gestisce la connessione, alla prima
2384 chiamata di una funzione che opera sul socket.
2386 È però possibile, dal punto di vista teorico, incorrere anche in uno scenario
2387 del tipo di quello mostrato in fig.~\ref{fig:TCP_early_abort}, in cui la
2388 connessione viene abortita sul lato client per un qualche errore di rete con
2389 l'invio di un segmento RST, prima che nel server sia stata chiamata la
2390 funzione \func{accept}.
2392 \begin{figure}[!htb]
2393 \centering \includegraphics[width=10cm]{img/tcp_client_early_abort}
2394 \caption{Un possibile caso di terminazione precoce della connessione.}
2395 \label{fig:TCP_early_abort}
2398 Benché questo non sia un fatto comune, un evento simile può essere osservato
2399 con dei server molto occupati. In tal caso, con una struttura del server
2400 simile a quella del nostro esempio, in cui la gestione delle singole
2401 connessioni è demandata a processi figli, può accadere che il \textit{three
2402 way handshake} venga completato e la relativa connessione abortita subito
2403 dopo, prima che il padre, per via del carico della macchina, abbia fatto in
2404 tempo ad eseguire la chiamata ad \func{accept}. Di nuovo si ha una situazione
2405 analoga a quella illustrata in fig.~\ref{fig:TCP_early_abort}, in cui la
2406 connessione viene stabilita, ma subito dopo si ha una condizione di errore che
2407 la chiude prima che essa sia stata accettata dal programma.
2409 Questo significa che oltre alla interruzione da parte di un segnale, che
2410 abbiamo trattato in sez.~\ref{sec:TCP_child_hand} nel caso particolare di
2411 \signal{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
2412 \func{accept}; questi, come nel caso precedente, necessitano semplicemente la
2413 ripetizione della chiamata senza uscire dal programma. In questo caso anche la
2414 versione modificata del nostro server non sarebbe adatta, in quanto uno di
2415 questi errori causerebbe la terminazione dello stesso. In Linux i possibili
2416 errori di rete non fatali, riportati sul socket connesso al ritorno di
2417 \func{accept}, sono \errcode{ENETDOWN}, \errcode{EPROTO},
2418 \errcode{ENOPROTOOPT}, \errcode{EHOSTDOWN}, \errcode{ENONET},
2419 \errcode{EHOSTUNREACH}, \errcode{EOPNOTSUPP} e \errcode{ENETUNREACH}.
2421 Si tenga presente che questo tipo di terminazione non è riproducibile
2422 terminando il client prima della chiamata ad \func{accept}, come si potrebbe
2423 fare usando l'opzione \texttt{-w} per introdurre una pausa dopo il lancio del
2424 demone, in modo da poter avere il tempo per lanciare e terminare una
2425 connessione usando il programma client. In tal caso infatti, alla terminazione
2426 del client, il socket associato alla connessione viene semplicemente chiuso,
2427 attraverso la sequenza vista in sez.~\ref{sec:TCP_conn_term}, per cui la
2428 \func{accept} ritornerà senza errori, e si avrà semplicemente un
2429 \textit{end-of-file} al primo accesso al socket. Nel caso di Linux inoltre,
2430 anche qualora si modifichi il client per fargli gestire l'invio di un segmento
2431 RST alla chiusura dal socket (usando l'opzione \const{SO\_LINGER}, vedi
2432 sez.~\ref{sec:sock_options_main}), non si ha comunque nessun errore al ritorno
2433 di \func{accept}, quanto un errore di \errcode{ECONNRESET} al primo tentativo
2434 di accesso al socket.
2438 \subsection{La terminazione precoce del server}
2439 \label{sec:TCP_server_crash}
2441 Un secondo caso critico è quello in cui si ha una terminazione precoce del
2442 server, ad esempio perché il programma ha un crash. In tal caso si suppone che
2443 il processo termini per un errore fatale, cosa che potremo simulare
2444 inviandogli un segnale di terminazione. La conclusione del processo comporta
2445 la chiusura di tutti i file descriptor aperti, compresi tutti i socket
2446 relativi a connessioni stabilite; questo significa che al momento del crollo
2447 del servizio il client riceverà un FIN dal server in corrispondenza della
2448 chiusura del socket.
2450 Vediamo allora cosa succede nel nostro caso, facciamo partire una connessione
2451 con il server e scriviamo una prima riga, poi terminiamo il server con un
2452 \texttt{C-c}. A questo punto scriviamo una seconda riga e poi un'altra riga
2453 ancora. Il risultato finale della sessione è il seguente:
2455 [piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
2458 Seconda riga dopo il C-c
2460 [piccardi@gont sources]$
2463 Come si vede il nostro client, nonostante la connessione sia stata interrotta
2464 prima dell'invio della seconda riga, non solo accetta di inviarla, ma prende
2465 anche un'altra riga prima di terminare senza riportare nessun
2468 Per capire meglio cosa è successo conviene analizzare il flusso dei pacchetti
2469 utilizzando un analizzatore di traffico come \cmd{tcpdump}. Il comando
2470 permette di selezionare, nel traffico di rete generato su una macchina, i
2471 pacchetti che interessano, stampando a video (o salvando su disco) il loro
2472 contenuto. Non staremo qui ad entrare nei dettagli dell'uso del programma, che
2473 sono spiegati dalla pagina di manuale;\footnote{per una trattazione di base si
2474 può consultare sez.~5.2.2 di \cite{SGL}.} per l'uso che vogliamo farne
2475 quello che ci interessa è, posizionandosi sulla macchina che fa da client,
2476 selezionare tutti i pacchetti che sono diretti o provengono dalla macchina che
2477 fa da server. In questo modo (posto che non ci siano altre connessioni col
2478 server, cosa che avremo cura di evitare) tutti i pacchetti rilevati
2479 apparterranno alla nostra sessione di interrogazione del servizio.
2481 Il comando \cmd{tcpdump} permette selezioni molto complesse, basate sulle
2482 interfacce su cui passano i pacchetti, sugli indirizzi IP, sulle porte, sulle
2483 caratteristiche ed il contenuto dei pacchetti stessi, inoltre permette di
2484 combinare fra loro diversi criteri di selezione con degli operatori logici;
2485 quando un pacchetto che corrisponde ai criteri di selezione scelti viene
2486 rilevato i suoi dati vengono stampati sullo schermo (anche questi secondo un
2487 formato configurabile in maniera molto precisa).
2489 Lanciando il comando prima di ripetere la sessione di lavoro mostrata
2490 nell'esempio precedente potremo allora catturare tutti pacchetti scambiati fra
2491 il client ed il server; i risultati (in realtà si è ridotta la lunghezza
2492 dell'output rispetto al reale tagliando alcuni dati non necessari alla
2493 comprensione del flusso) prodotti in questa occasione da \cmd{tcpdump} sono
2496 [root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
2497 tcpdump: listening on eth0
2498 gont.34559 > anarres.echo: S 800922320:800922320(0) win 5840
2499 anarres.echo > gont.34559: S 511689719:511689719(0) ack 800922321 win 5792
2500 gont.34559 > anarres.echo: . ack 1 win 5840
2501 gont.34559 > anarres.echo: P 1:12(11) ack 1 win 5840
2502 anarres.echo > gont.34559: . ack 12 win 5792
2503 anarres.echo > gont.34559: P 1:12(11) ack 12 win 5792
2504 gont.34559 > anarres.echo: . ack 12 win 5840
2505 anarres.echo > gont.34559: F 12:12(0) ack 12 win 5792
2506 gont.34559 > anarres.echo: . ack 13 win 5840
2507 gont.34559 > anarres.echo: P 12:37(25) ack 13 win 5840
2508 anarres.echo > gont.34559: R 511689732:511689732(0) win 0
2511 Le prime tre righe vengono prodotte al momento in cui lanciamo il nostro
2512 client, e corrispondono ai tre pacchetti del \textit{three way handshake}.
2513 L'output del comando riporta anche i numeri di sequenza iniziali, mentre la
2514 lettera \texttt{S} indica che per quel pacchetto si aveva il SYN flag attivo.
2515 Si noti come a partire dal secondo pacchetto sia sempre attivo il campo
2516 \texttt{ack}, seguito dal numero di sequenza per il quale si da il ricevuto;
2517 quest'ultimo, a partire dal terzo pacchetto, viene espresso in forma relativa
2518 per maggiore compattezza. Il campo \texttt{win} in ogni riga indica la
2519 \textit{advertised window} di cui parlavamo in sez.~\ref{sec:TCP_TCP_opt}.
2521 Allora si può verificare dall'output del comando come venga appunto realizzata
2522 la sequenza di pacchetti descritta in sez.~\ref{sec:TCP_conn_cre}: prima viene
2523 inviato dal client un primo pacchetto con il SYN che inizia la connessione, a
2524 cui il server risponde dando il ricevuto con un secondo pacchetto, che a sua
2525 volta porta un SYN, cui il client risponde con un il terzo pacchetto di
2528 Ritorniamo allora alla nostra sessione con il servizio echo: dopo le tre righe
2529 del \textit{three way handshake} non avremo nulla fin tanto che non scriveremo
2530 una prima riga sul client; al momento in cui facciamo questo si genera una
2531 sequenza di altri quattro pacchetti. Il primo, dal client al server,
2532 contraddistinto da una lettera \texttt{P} che significa che il flag PSH è
2533 impostato, contiene la nostra riga (che è appunto di 11 caratteri), e ad esso
2534 il server risponde immediatamente con un pacchetto vuoto di ricevuto.
2536 Poi tocca al server riscrivere indietro quanto gli è stato inviato, per cui
2537 sarà lui a mandare indietro un terzo pacchetto con lo stesso contenuto appena
2538 ricevuto, e a sua volta riceverà dal client un ACK nel quarto pacchetto.
2539 Questo causerà la ricezione dell'eco nel client che lo stamperà a video.
2541 A questo punto noi procediamo ad interrompere l'esecuzione del server con un
2542 \texttt{C-c} (cioè con l'invio di \signal{SIGTERM}): nel momento in cui
2543 facciamo questo vengono immediatamente generati altri due pacchetti. La
2544 terminazione del processo infatti comporta la chiusura di tutti i suoi file
2545 descriptor, il che comporta, per il socket che avevamo aperto, l'inizio della
2546 sequenza di chiusura illustrata in sez.~\ref{sec:TCP_conn_term}. Questo
2547 significa che dal server partirà un FIN, che è appunto il primo dei due
2548 pacchetti, contraddistinto dalla lettera \texttt{F}, cui seguirà al solito un
2549 ACK da parte del client.
2551 A questo punto la connessione dalla parte del server è chiusa, ed infatti se
2552 usiamo \cmd{netstat} per controllarne lo stato otterremo che sul server si ha:
2554 anarres:/home/piccardi# \textbf{netstat -ant}
2555 Active Internet connections (servers and established)
2556 Proto Recv-Q Send-Q Local Address Foreign Address State
2557 ... ... ... ... ... ...
2558 tcp 0 0 192.168.1.141:7 192.168.1.2:34626 FIN_WAIT2
2560 cioè essa è andata nello stato \texttt{FIN\_WAIT2}, che indica l'avvenuta
2561 emissione del segmento FIN, mentre sul client otterremo che essa è andata
2562 nello stato \texttt{CLOSE\_WAIT}:
2564 [root@gont gapil]# \textbf{netstat -ant}
2565 Active Internet connections (servers and established)
2566 Proto Recv-Q Send-Q Local Address Foreign Address State
2567 ... ... ... ... ... ...
2568 tcp 1 0 192.168.1.2:34582 192.168.1.141:7 CLOSE_WAIT
2571 Il problema è che in questo momento il client è bloccato dentro la funzione
2572 \texttt{ClientEcho} nella chiamata a \func{fgets}, e sta attendendo dell'input
2573 dal terminale, per cui non è in grado di accorgersi di nulla. Solo quando
2574 inseriremo la seconda riga il comando uscirà da \func{fgets} e proverà a
2575 scriverla sul socket. Questo comporta la generazione degli ultimi due
2576 pacchetti riportati da \cmd{tcpdump}: il primo, inviato dal client contenente
2577 i 25 caratteri della riga appena letta, e ad esso la macchina server
2578 risponderà, non essendoci più niente in ascolto sulla porta 7, con un segmento
2579 di RST, contraddistinto dalla lettera \texttt{R}, che causa la conclusione
2580 definitiva della connessione anche nel client, dove non comparirà più
2581 nell'output di \cmd{netstat}.
2583 Come abbiamo accennato in sez.~\ref{sec:TCP_conn_term} e come vedremo più
2584 avanti in sez.~\ref{sec:TCP_shutdown} la chiusura di un solo capo di un socket
2585 è una operazione lecita, per cui la nostra scrittura avrà comunque successo
2586 (come si può constatare lanciando usando \cmd{strace}\footnote{il comando
2587 \cmd{strace} è un comando di debug molto utile che prende come argomento un
2588 altro comando e ne stampa a video tutte le invocazioni di una \textit{system
2589 call}, coi relativi argomenti e valori di ritorno, per cui usandolo in
2590 questo contesto potremo verificare che effettivamente la \func{write} ha
2591 scritto la riga, che in effetti è stata pure trasmessa via rete.}), in
2592 quanto il nostro programma non ha a questo punto alcun modo di sapere che
2593 dall'altra parte non c'è più nessuno processo in grado di leggere quanto
2594 scriverà. Questo sarà chiaro solo dopo il tentativo di scrittura, e la
2595 ricezione del segmento RST di risposta che indica che dall'altra parte non si
2596 è semplicemente chiuso un capo del socket, ma è completamente terminato il
2599 Per questo motivo il nostro client proseguirà leggendo dal socket, e dato che
2600 questo è stato chiuso avremo che, come spiegato in
2601 sez.~\ref{sec:TCP_conn_term}, la funzione \func{read} ritorna normalmente con
2602 un valore nullo. Questo comporta che la seguente chiamata a \func{fputs} non
2603 ha effetto (viene stampata una stringa nulla) ed il client si blocca di nuovo
2604 nella successiva chiamata a \func{fgets}. Per questo diventa possibile
2605 inserire una terza riga e solo dopo averlo fatto si avrà la terminazione del
2608 Per capire come questa avvenga comunque, non avendo inserito nel codice nessun
2609 controllo di errore, occorre ricordare che, a parte la bidirezionalità del
2610 flusso dei dati, dal punto di vista del funzionamento nei confronti delle
2611 funzioni di lettura e scrittura, i socket sono del tutto analoghi a delle
2612 \textit{pipe}. Allora, da quanto illustrato in sez.~\ref{sec:ipc_pipes},
2613 sappiamo che tutte le volte che si cerca di scrivere su una \textit{pipe} il
2614 cui altro capo non è aperto il lettura il processo riceve un segnale di
2615 \signal{SIGPIPE}, e questo è esattamente quello che avviene in questo caso, e
2616 siccome non abbiamo un gestore per questo segnale, viene eseguita l'azione
2617 preimpostata, che è quella di terminare il processo.
2619 Per gestire in maniera più corretta questo tipo di evento dovremo allora
2620 modificare il nostro client perché sia in grado di trattare le varie tipologie
2621 di errore, per questo dovremo riscrivere la funzione \func{ClientEcho}, in
2622 modo da controllare gli stati di uscita delle varie chiamate. Si è riportata
2623 la nuova versione della funzione in fig.~\ref{fig:TCP_ClientEcho_second}.
2625 \begin{figure}[!htb]
2626 \footnotesize \centering
2627 \begin{minipage}[c]{\codesamplewidth}
2628 \includecodesample{listati/ClientEcho_second.c}
2631 \caption{La sezione nel codice della seconda versione della funzione
2632 \func{ClientEcho} usata dal client per il servizio \textit{echo}
2633 modificata per tener conto degli eventuali errori.}
2634 \label{fig:TCP_ClientEcho_second}
2637 Come si può vedere in questo caso si controlla il valore di ritorno di tutte
2638 le funzioni, ed inoltre si verifica la presenza di un eventuale
2639 \textit{end-of-file} in caso di lettura. Con questa modifica il nostro client
2640 \cmd{echo} diventa in grado di accorgersi della chiusura del socket da parte
2641 del server, per cui ripetendo la sequenza di operazioni precedenti stavolta
2644 [piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
2647 Seconda riga dopo il C-c
2651 ma di nuovo si tenga presente che non c'è modo di accorgersi della chiusura
2652 del socket fin quando non si esegue la scrittura della seconda riga; il
2653 protocollo infatti prevede che ci debba essere una scrittura prima di ricevere
2654 un RST che confermi la chiusura del file, e solo alle successive scritture si
2655 potrà ottenere un errore.
2657 Questa caratteristica dei socket ci mette di fronte ad un altro problema
2658 relativo al nostro client, e che cioè esso non è in grado di accorgersi di
2659 nulla fintanto che è bloccato nella lettura del terminale fatta con
2660 \func{gets}. In questo caso il problema è minimo, ma esso riemergerà più
2661 avanti, ed è quello che si deve affrontare tutte le volte quando si ha a che
2662 fare con la necessità di lavorare con più descrittori, nel qual caso si pone
2663 la questione di come fare a non restare bloccati su un socket quando altri
2664 potrebbero essere liberi. Vedremo come affrontare questa problematica in
2665 sez.~\ref{sec:TCP_sock_multiplexing}.
2668 \subsection{Altri scenari di terminazione della connessione}
2669 \label{sec:TCP_conn_crash}
2671 La terminazione del server è solo uno dei possibili scenari di terminazione
2672 della connessione, un altro caso è ad esempio quello in cui si ha
2673 un'interruzione sulla rete, cosa che potremo simulare facilmente staccando il
2674 cavo di rete. Un'altra condizione è quella di un blocco completo della
2675 macchina su cui gira il server che deve essere riavviata, cosa che potremo
2676 simulare sia eseguendo un reset fisico (un normale shutdown non va bene; in
2677 tal caso infatti il sistema provvede a terminare tutti i processi, per cui la
2678 situazione sarebbe sostanzialmente identica alla precedente) oppure, in
2679 maniera più gentile, riavviando la macchina dopo aver interrotto la
2680 connessione di rete.
2682 Cominciamo ad analizzare il primo caso, l'interruzione del collegamento di
2683 rete. Ripetiamo la nostra sessione di lavoro precedente, lanciamo il client,
2684 scriviamo una prima riga, poi stacchiamo il cavo e scriviamo una seconda
2685 riga. Il risultato che otterremo è:
2687 [piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
2690 Seconda riga dopo l'interruzione
2691 Errore in lettura: No route to host
2695 Quello che succede in questo è che il programma, dopo aver scritto la seconda
2696 riga, resta bloccato per un tempo molto lungo, prima di dare l'errore
2697 \errcode{EHOSTUNREACH}. Se andiamo ad osservare con \cmd{strace} cosa accade
2698 nel periodo in cui il programma è bloccato vedremo che stavolta, a differenza
2699 del caso precedente, il programma è bloccato nella lettura dal socket.
2701 Se poi, come nel caso precedente, usiamo l'accortezza di analizzare il
2702 traffico di rete fra client e server con \cmd{tcpdump}, otterremo il seguente
2705 [root@gont sources]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
2706 tcpdump: listening on eth0
2707 gont.34685 > anarres.echo: S 1943495663:1943495663(0) win 5840
2708 anarres.echo > gont.34685: S 1215783131:1215783131(0) ack 1943495664 win 5792
2709 gont.34685 > anarres.echo: . ack 1 win 5840
2710 gont.34685 > anarres.echo: P 1:12(11) ack 1 win 5840
2711 anarres.echo > gont.34685: . ack 12 win 5792
2712 anarres.echo > gont.34685: P 1:12(11) ack 12 win 5792
2713 gont.34685 > anarres.echo: . 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 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840
2722 gont.34685 > anarres.echo: P 12:45(33) ack 12 win 5840
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 arp who-has anarres tell gont
2728 arp who-has anarres tell gont
2732 In questo caso l'andamento dei primi sette pacchetti è esattamente lo stesso
2733 di prima. Solo che stavolta, non appena inviata la seconda riga, il programma
2734 si bloccherà nella successiva chiamata a \func{read}, non ottenendo nessuna
2735 risposta. Quello che succede è che nel frattempo il kernel provvede, come
2736 richiesto dal protocollo TCP, a tentare la ritrasmissione della nostra riga un
2737 certo numero di volte, con tempi di attesa crescente fra un tentativo ed il
2738 successivo, per tentare di ristabilire la connessione.
2740 Il risultato finale qui dipende dalla realizzazione dello \textit{stack TCP},
2741 e nel caso di Linux anche dall'impostazione di alcuni dei parametri di sistema
2742 che si trovano in \file{/proc/sys/net/ipv4}, che ne controllano il
2743 comportamento: in questo caso in particolare da
2744 \sysctlrelfile{net/ipv4}{tcp\_retries2} (vedi
2745 sez.~\ref{sec:sock_ipv4_sysctl}). Questo parametro infatti specifica il numero
2746 di volte che deve essere ritentata la ritrasmissione di un pacchetto nel mezzo
2747 di una connessione prima di riportare un errore di timeout. Il valore
2748 preimpostato è pari a 15, il che comporterebbe 15 tentativi di ritrasmissione,
2749 ma nel nostro caso le cose sono andate diversamente, dato che le
2750 ritrasmissioni registrate da \cmd{tcpdump} sono solo 8; inoltre l'errore
2751 riportato all'uscita del client non è stato \errcode{ETIMEDOUT}, come dovrebbe
2752 essere in questo caso, ma \errcode{EHOSTUNREACH}.
2754 Per capire l'accaduto continuiamo ad analizzare l'output di \cmd{tcpdump}:
2755 esso ci mostra che a un certo punto i tentativi di ritrasmissione del
2756 pacchetto sono cessati, per essere sostituiti da una serie di richieste di
2757 protocollo ARP in cui il client richiede l'indirizzo del server.
2759 Come abbiamo accennato in sez.~\ref{sec:net_tcpip_general} ARP è il protocollo
2760 che si incarica di trovare le corrispondenze fra indirizzo IP e indirizzo
2761 hardware sulla scheda di rete. È evidente allora che nel nostro caso, essendo
2762 client e server sulla stessa rete, è scaduta la voce nella \textit{ARP
2763 cache}\footnote{la \textit{ARP cache} è una tabella mantenuta internamente
2764 dal kernel che contiene tutte le corrispondenze fra indirizzi IP e indirizzi
2765 fisici, ottenute appunto attraverso il protocollo ARP; le voci della tabella
2766 hanno un tempo di vita limitato, passato il quale scadono e devono essere
2767 nuovamente richieste.} relativa ad \texttt{anarres}, ed il nostro client ha
2768 iniziato ad effettuare richieste ARP sulla rete per sapere l'IP di
2769 quest'ultimo, che essendo scollegato non poteva rispondere. Anche per questo
2770 tipo di richieste esiste un timeout, per cui dopo un certo numero di tentativi
2771 il meccanismo si è interrotto, e l'errore riportato al programma a questo
2772 punto è stato \errcode{EHOSTUNREACH}, in quanto non si era più in grado di
2773 contattare il server.
2775 Un altro errore possibile in questo tipo di situazione, che si può avere
2776 quando la macchina è su una rete remota, è \errcode{ENETUNREACH}; esso viene
2777 riportato alla ricezione di un pacchetto ICMP di \textit{destination
2778 unreachable} da parte del router che individua l'interruzione della
2779 connessione. Di nuovo anche qui il risultato finale dipende da quale è il
2780 meccanismo più veloce che porta ad accorgersi del problema.
2782 Se però agiamo sui parametri del kernel, e scriviamo in \file{tcp\_retries2}
2783 un valore di tentativi più basso, possiamo evitare la scadenza della
2784 \textit{ARP cache} e vedere cosa succede. Così se ad esempio richiediamo 4
2785 tentativi di ritrasmissione, l'analisi di \cmd{tcpdump} ci riporterà il
2786 seguente scambio di pacchetti:
2788 [root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
2789 tcpdump: listening on eth0
2790 gont.34752 > anarres.echo: S 3646972152:3646972152(0) win 5840
2791 anarres.echo > gont.34752: S 2735190336:2735190336(0) ack 3646972153 win 5792
2792 gont.34752 > anarres.echo: . ack 1 win 5840
2793 gont.34752 > anarres.echo: P 1:12(11) ack 1 win 5840
2794 anarres.echo > gont.34752: . ack 12 win 5792
2795 anarres.echo > gont.34752: P 1:12(11) ack 12 win 5792
2796 gont.34752 > anarres.echo: . 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 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840
2801 gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840
2803 e come si vede in questo caso i tentativi di ritrasmissione del pacchetto
2804 iniziale sono proprio 4 (per un totale di 5 voci con quello trasmesso la prima
2805 volta), ed in effetti, dopo un tempo molto più breve rispetto a prima ed in
2806 corrispondenza dell'invio dell'ultimo tentativo, quello che otterremo come
2807 errore all'uscita del client sarà diverso, e cioè:
2809 [piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
2812 Seconda riga dopo l'interruzione
2813 Errore in lettura: Connection timed out
2816 che corrisponde appunto, come ci aspettavamo, alla ricezione di un
2817 \errcode{ETIMEDOUT}.
2819 Analizziamo ora il secondo scenario, in cui si ha un crollo della macchina che
2820 fa da server. Al solito lanciamo il nostro client, scriviamo una prima riga
2821 per verificare che sia tutto a posto, poi stacchiamo il cavo e riavviamo il
2822 server. A questo punto, ritornato attivo il server, scriviamo una seconda
2823 riga. Quello che otterremo in questo caso è:
2825 [piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
2828 Seconda riga dopo l'interruzione
2829 Errore in lettura Connection reset by peer
2832 e l'errore ricevuti da \func{read} stavolta è \errcode{ECONNRESET}. Se al
2833 solito riportiamo l'analisi dei pacchetti effettuata con \cmd{tcpdump},
2836 [root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
2837 tcpdump: listening on eth0
2838 gont.34756 > anarres.echo: S 904864257:904864257(0) win 5840
2839 anarres.echo > gont.34756: S 4254564871:4254564871(0) ack 904864258 win 5792
2840 gont.34756 > anarres.echo: . ack 1 win 5840
2841 gont.34756 > anarres.echo: P 1:12(11) ack 1 win 5840
2842 anarres.echo > gont.34756: . ack 12 win 5792
2843 anarres.echo > gont.34756: P 1:12(11) ack 12 win 5792
2844 gont.34756 > anarres.echo: . ack 12 win 5840
2845 gont.34756 > anarres.echo: P 12:45(33) ack 12 win 5840
2846 anarres.echo > gont.34756: R 4254564883:4254564883(0) win 0
2849 Ancora una volta i primi sette pacchetti sono gli stessi; ma in questo caso
2850 quello che succede dopo lo scambio iniziale è che, non avendo inviato nulla
2851 durante il periodo in cui si è riavviato il server, il client è del tutto
2852 ignaro dell'accaduto per cui quando effettuerà una scrittura, dato che la
2853 macchina server è stata riavviata e che tutti gli stati relativi alle
2854 precedenti connessioni sono completamente persi, anche in presenza di una
2855 nuova istanza del server echo non sarà possibile consegnare i dati in arrivo,
2856 per cui alla loro ricezione il kernel risponderà con un segmento di RST.
2858 Il client da parte sua, dato che neanche in questo caso non è stato emesso un
2859 FIN, dopo aver scritto verrà bloccato nella successiva chiamata a \func{read},
2860 che però adesso ritornerà immediatamente alla ricezione del segmento RST,
2861 riportando appunto come errore \errcode{ECONNRESET}. Occorre precisare che se
2862 si vuole che il client sia in grado di accorgersi del crollo del server anche
2863 quando non sta effettuando uno scambio di dati, è possibile usare una
2864 impostazione speciale del socket (ci torneremo in
2865 sez.~\ref{sec:sock_generic_options}) che provvede all'esecuzione di questo
2869 \section{L'uso dell'\textit{I/O multiplexing}}
2870 \label{sec:TCP_sock_multiplexing}
2872 Affronteremo in questa sezione l'utilizzo dell'\textit{I/O multiplexing},
2873 affrontato in sez.~\ref{sec:file_multiplexing}, nell'ambito delle applicazioni
2874 di rete. Già in sez.~\ref{sec:TCP_server_crash} era emerso il problema
2875 relativo al client del servizio \textit{echo} che non era in grado di
2876 accorgersi della terminazione precoce del server, essendo bloccato nella
2877 lettura dei dati immessi da tastiera.
2879 Abbiamo visto in sez.~\ref{sec:file_multiplexing} quali sono le funzionalità
2880 del sistema che ci permettono di tenere sotto controllo più file descriptor in
2881 contemporanea; in quella occasione non abbiamo fatto esempi, in quanto quando
2882 si tratta con file normali questa tipologia di I/O normalmente non viene
2883 usata, è invece un caso tipico delle applicazioni di rete quello di dover
2884 gestire varie connessioni da cui possono arrivare dati comuni in maniera
2885 asincrona, per cui riprenderemo l'argomento in questa sezione.
2888 \subsection{Il comportamento della funzione \func{select} con i socket.}
2889 \label{sec:TCP_sock_select}
2891 Iniziamo con la prima delle funzioni usate per l'\textit{I/O multiplexing},
2892 \func{select}; il suo funzionamento è già stato descritto in dettaglio in
2893 sez.~\ref{sec:file_multiplexing} e non staremo a ripetere quanto detto lì;
2894 sappiamo che la funzione ritorna quando uno o più dei file descriptor messi
2895 sotto controllo è pronto per la relativa operazione.
2897 In quell'occasione non abbiamo però definito cosa si intende per pronto,
2898 infatti per dei normali file, o anche per delle \textit{pipe}, la condizione
2899 di essere pronti per la lettura o la scrittura è ovvia; invece lo è molto meno
2900 nel caso dei socket, visto che possono intervenire tutte una serie di
2901 possibili condizioni di errore dovute alla rete. Occorre allora specificare
2902 chiaramente quali sono le condizioni per cui un socket risulta essere
2903 ``\textsl{pronto}'' quando viene passato come membro di uno dei tre
2904 \textit{file descriptor set} usati da \func{select}.
2906 Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
2907 che un socket (che sarà riportato nel primo insieme di file descriptor) è
2908 pronto per la lettura sono le seguenti:
2910 \item nel buffer di ricezione del socket sono arrivati dei dati in quantità
2911 sufficiente a superare il valore di una \textsl{soglia di basso livello} (il
2912 cosiddetto \textit{low watermark}). Questo valore è espresso in numero di
2913 byte e può essere impostato con l'opzione del socket \const{SO\_RCVLOWAT}
2914 (tratteremo l'uso di questa opzione in sez.~\ref{sec:sock_generic_options});
2915 il suo valore di default è 1 per i socket TCP e UDP. In questo caso una
2916 operazione di lettura avrà successo e leggerà un numero di byte maggiore di
2918 \item il lato in lettura della connessione è stato chiuso; si è cioè ricevuto
2919 un segmento FIN (si ricordi quanto illustrato in
2920 sez.~\ref{sec:TCP_conn_term}) sulla connessione. In questo caso una
2921 operazione di lettura avrà successo, ma non risulteranno presenti dati (in
2922 sostanza \func{read} ritornerà con un valore nullo) per indicare la
2923 condizione di \textit{end-of-file}.
2924 \item c'è stato un errore sul socket. In questo caso una operazione di lettura
2925 non si bloccherà ma restituirà una condizione di errore (ad esempio
2926 \func{read} restituirà $-1$) e imposterà la variabile \var{errno} al relativo
2927 valore. Vedremo in sez.~\ref{sec:sock_generic_options} come sia possibile
2928 estrarre e cancellare gli errori pendenti su un socket senza usare
2929 \func{read} usando l'opzione \const{SO\_ERROR}.
2930 \item quando si sta utilizzando un \textit{listening socket} ed ci sono delle
2931 connessioni completate. In questo caso la funzione \func{accept} non si
2932 bloccherà.\footnote{in realtà questo non è sempre vero, come accennato in
2933 sez.~\ref{sec:TCP_conn_early_abort} una connessione può essere abortita
2934 dalla ricezione di un segmento RST una volta che è stata completata,
2935 allora se questo avviene dopo che \func{select} è ritornata, ma prima
2936 della chiamata ad \func{accept}, quest'ultima, in assenza di altre
2937 connessioni, potrà bloccarsi.}
2940 Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
2941 che un socket (che sarà riportato nel secondo insieme di file descriptor) è
2942 pronto per la scrittura sono le seguenti:
2944 \item nel buffer di invio è disponibile una quantità di spazio superiore al
2945 valore della \textsl{soglia di basso livello} in scrittura ed inoltre o il
2946 socket è già connesso o non necessita (ad esempio è UDP) di connessione. Il
2947 valore della soglia è espresso in numero di byte e può essere impostato con
2948 l'opzione del socket \const{SO\_SNDLOWAT} (trattata in
2949 sez.~\ref{sec:sock_generic_options}); il suo valore di default è 2048 per i
2950 socket TCP e UDP. In questo caso una operazione di scrittura non si
2951 bloccherà e restituirà un valore positivo pari al numero di byte accettati
2952 dal livello di trasporto.
2953 \item il lato in scrittura della connessione è stato chiuso. In questo caso
2954 una operazione di scrittura sul socket genererà il segnale \signal{SIGPIPE}.
2955 \item c'è stato un errore sul socket. In questo caso una operazione di
2956 scrittura non si bloccherà ma restituirà una condizione di errore ed
2957 imposterà opportunamente la variabile \var{errno}. Vedremo in
2958 sez.~\ref{sec:sock_generic_options} come sia possibile estrarre e cancellare
2959 errori pendenti su un socket usando l'opzione \const{SO\_ERROR}.
2962 Infine c'è una sola condizione che fa sì che \func{select} ritorni segnalando
2963 che un socket (che sarà riportato nel terzo insieme di file descriptor) ha una
2964 condizione di eccezione pendente, e cioè la ricezione sul socket di
2965 \textsl{dati urgenti} (o \textit{out-of-band}), una caratteristica specifica
2966 dei socket TCP su cui torneremo in sez.~\ref{sec:TCP_urgent_data}.
2968 Si noti come nel caso della lettura \func{select} si applichi anche ad
2969 operazioni che non hanno nulla a che fare con l'I/O di dati come il
2970 riconoscimento della presenza di connessioni pronte, in modo da consentire
2971 anche l'utilizzo di \func{accept} in modalità non bloccante. Si noti infine
2972 come in caso di errore un socket venga sempre riportato come pronto sia per la
2973 lettura che per la scrittura.
2975 Lo scopo dei due valori di soglia per i buffer di ricezione e di invio è
2976 quello di consentire maggiore flessibilità nell'uso di \func{select} da parte
2977 dei programmi, se infatti si sa che una applicazione non è in grado di fare
2978 niente fintanto che non può ricevere o inviare una certa quantità di dati, si
2979 possono utilizzare questi valori per far sì che \func{select} ritorni solo
2980 quando c'è la certezza di avere dati a sufficienza.\footnote{questo tipo di
2981 controllo è utile di norma solo per la lettura, in quanto in genere le
2982 operazioni di scrittura sono già controllate dall'applicazione, che sa
2983 sempre quanti dati invia, mentre non è detto possa conoscere la quantità di
2984 dati in ricezione; per cui, nella situazione in cui si conosce almeno un
2985 valore minimo, per evitare la penalizzazione dovuta alla ripetizione delle
2986 operazioni di lettura per accumulare dati sufficienti, si può lasciare al
2987 kernel il compito di impostare un minimo al di sotto del quale il socket,
2988 pur avendo disponibili dei dati, non viene dato per pronto in lettura.}
2992 \subsection{Un esempio di \textit{I/O multiplexing}}
2993 \label{sec:TCP_multiplex_example}
2995 Abbiamo incontrato la problematica tipica che conduce all'uso dell'\textit{I/O
2996 multiplexing} nella nostra analisi degli errori in
2997 sez.~\ref{sec:TCP_conn_early_abort}, quando il nostro client non era in grado
2998 di rendersi conto di errori sulla connessione essendo impegnato nella attesa
2999 di dati in ingresso dallo \textit{standard input}.
3001 In questo caso il problema è quello di dover tenere sotto controllo due
3002 diversi file descriptor, lo \textit{standard input}, da cui viene letto il
3003 testo che vogliamo inviare al server, e il socket connesso con il server su
3004 cui detto testo sarà scritto e dal quale poi si vorrà ricevere la
3005 risposta. L'uso dell'\textit{I/O multiplexing} consente di tenere sotto controllo
3006 entrambi, senza restare bloccati.
3008 Nel nostro caso quello che ci interessa è non essere bloccati in lettura sullo
3009 \textit{standard input} in caso di errori sulla connessione o chiusura della
3010 stessa da parte del server. Entrambi questi casi possono essere rilevati
3011 usando \func{select}, per quanto detto in sez.~\ref{sec:TCP_sock_select},
3012 mettendo sotto osservazione i file descriptor per la condizione di essere
3013 pronti in lettura: sia infatti che si ricevano dati, che la connessione sia
3014 chiusa regolarmente (con la ricezione di un segmento FIN) che si riceva una
3015 condizione di errore (con un segmento RST) il socket connesso sarà pronto in
3016 lettura (nell'ultimo caso anche in scrittura, ma questo non è necessario ai
3019 \begin{figure}[!htb]
3020 \footnotesize \centering
3021 \begin{minipage}[c]{\codesamplewidth}
3022 \includecodesample{listati/ClientEcho_third.c}
3025 \caption{La sezione nel codice della terza versione della funzione
3026 \func{ClientEcho} usata dal client per il servizio \textit{echo}
3027 modificata per l'uso di \func{select}.}
3028 \label{fig:TCP_ClientEcho_third}
3031 Riprendiamo allora il codice del client, modificandolo per l'uso di
3032 \func{select}. Quello che dobbiamo modificare è la funzione \func{ClientEcho}
3033 di fig.~\ref{fig:TCP_ClientEcho_second}, dato che tutto il resto, che riguarda
3034 le modalità in cui viene stabilita la connessione con il server, resta
3035 assolutamente identico. La nostra nuova versione di \func{ClientEcho}, la
3036 terza della serie, è riportata in fig.~\ref{fig:TCP_ClientEcho_third}, il
3037 codice completo si trova nel file \file{TCP\_echo\_third.c} dei sorgenti
3038 allegati alla guida.
3040 In questo caso la funzione comincia (\texttt{\small 8--9}) con l'azzeramento
3041 del \textit{file descriptor set} \var{fset} e l'impostazione del valore
3042 \var{maxfd}, da passare a \func{select} come massimo per il numero di file
3043 descriptor. Per determinare quest'ultimo si usa la macro \code{max} definita
3044 nel nostro file \file{macro.h} che raccoglie una collezione di macro di
3045 preprocessore di varia utilità.
3047 La funzione prosegue poi (\texttt{\small 10--41}) con il ciclo principale, che
3048 viene ripetuto indefinitamente. Per ogni ciclo si reinizializza
3049 (\texttt{\small 11--12}) il \textit{file descriptor set}, impostando i valori
3050 per il file descriptor associato al socket \var{socket} e per lo
3051 \textit{standard input} (il cui valore si recupera con la funzione
3052 \func{fileno}). Questo è necessario in quanto la successiva (\texttt{\small
3053 13}) chiamata a \func{select} comporta una modifica dei due bit relativia
3054 questi file, che quindi devono essere reimpostati all'inizio di ogni ciclo.
3056 Si noti come la chiamata a \func{select} venga eseguita usando come primo
3057 argomento il valore di \var{maxfd}, precedentemente calcolato, e passando poi
3058 il solo \textit{file descriptor set} per il controllo dell'attività in
3059 lettura, negli altri argomenti vengono passati tutti puntatori nulli, non
3060 interessando in questo caso né il controllo delle altre attività, né
3061 l'impostazione di un valore di timeout.
3063 Al ritorno di \func{select} si provvede a controllare quale dei due file
3064 descriptor presenta attività in lettura, cominciando (\texttt{\small 14--24})
3065 con il file descriptor associato allo \textit{standard input}. In caso di
3066 attività (quando cioè \macro{FD\_ISSET} ritorna una valore diverso da zero) si
3067 esegue (\texttt{\small 15}) una \func{fgets} per leggere gli eventuali dati
3068 presenti; se non ve ne sono (e la funzione restituisce pertanto un puntatore
3069 nullo) si ritorna immediatamente (\texttt{\small 16}) dato che questo
3070 significa che si è chiuso lo \textit{standard input} e quindi concluso l'utilizzo del
3071 client; altrimenti (\texttt{\small 18--22}) si scrivono i dati appena letti
3072 sul socket, prevedendo una uscita immediata in caso di errore di scrittura.
3074 Controllato lo \textit{standard input} si passa a controllare (\texttt{\small
3075 25--40}) il socket connesso, in caso di attività (\texttt{\small 26}) si
3076 esegue subito una \func{read} di cui si controlla il valore di ritorno; se
3077 questo è negativo si è avuto un errore e pertanto si esce immediatamente
3078 segnalandolo (\texttt{\small 27--30}), se è nullo significa che il server ha
3079 chiuso la connessione, e di nuovo si esce con stampando prima un messaggio di
3080 avviso (\texttt{\small 31--34}), altrimenti (\texttt{\small 35--39}) si
3081 effettua la terminazione della stringa e la si stampa a sullo \textit{standard
3082 output}, uscendo in caso di errore, per ripetere il ciclo da capo.
3084 Con questo meccanismo il programma invece di essere bloccato in lettura sullo
3085 \textit{standard input} resta bloccato sulla \func{select}, che ritorna
3086 soltanto quando viene rilevata attività su uno dei due file descriptor posti
3087 sotto controllo. Questo di norma avviene solo quando si è scritto qualcosa
3088 sullo \textit{standard input}, o quando si riceve dal socket la risposta a quanto si
3091 Ma adesso il client diventa capace di accorgersi immediatamente della
3092 terminazione del server; in tal caso infatti il server chiuderà il socket
3093 connesso, ed alla ricezione del FIN la funzione \func{select} ritornerà (come
3094 illustrato in sez.~\ref{sec:TCP_sock_select}) segnalando una condizione di end
3095 of file, per cui il nostro client potrà uscire immediatamente.
3097 Riprendiamo la situazione affrontata in sez.~\ref{sec:TCP_server_crash},
3098 terminando il server durante una connessione, in questo caso quello che
3099 otterremo, una volta scritta una prima riga ed interrotto il server con un
3102 [piccardi@gont sources]$ \textbf{./echo 192.168.1.1}
3108 dove l'ultima riga compare immediatamente dopo aver interrotto il server. Il
3109 nostro client infatti è in grado di accorgersi immediatamente che il socket
3110 connesso è stato chiuso ed uscire immediatamente.
3112 Veniamo allora agli altri scenari di terminazione anomala visti in
3113 sez.~\ref{sec:TCP_conn_crash}. Il primo di questi è l'interruzione fisica della
3114 connessione; in questo caso avremo un comportamento analogo al precedente, in
3115 cui si scrive una riga e non si riceve risposta dal server e non succede
3116 niente fino a quando non si riceve un errore di \errcode{EHOSTUNREACH} o
3117 \errcode{ETIMEDOUT} a seconda dei casi.
3119 La differenza è che stavolta potremo scrivere più righe dopo l'interruzione,
3120 in quanto il nostro client dopo aver inviato i dati non si bloccherà più nella
3121 lettura dal socket, ma nella \func{select}; per questo potrà accettare
3122 ulteriore dati che scriverà di nuovo sul socket, fintanto che c'è spazio sul
3123 buffer di uscita (ecceduto il quale si bloccherà in scrittura).
3125 Si ricordi infatti che il client non ha modo di determinare se la connessione
3126 è attiva o meno (dato che in molte situazioni reali l'inattività può essere
3127 temporanea). Tra l'altro se si ricollega la rete prima della scadenza del
3128 timeout, potremo anche verificare come tutto quello che si era scritto viene
3129 poi effettivamente trasmesso non appena la connessione ridiventa attiva, per
3130 cui otterremo qualcosa del tipo:
3132 [piccardi@gont sources]$ \textbf{./echo 192.168.1.1}
3135 Seconda riga dopo l'interruzione
3138 Seconda riga dopo l'interruzione
3143 in cui, una volta riconnessa la rete, tutto quello che abbiamo scritto durante
3144 il periodo di disconnessione restituito indietro e stampato immediatamente.
3146 Lo stesso comportamento visto in sez.~\ref{sec:TCP_server_crash} si riottiene
3147 nel caso di un crollo completo della macchina su cui sta il server. In questo
3148 caso di nuovo il client non è in grado di accorgersi di niente dato che si
3149 suppone che il programma server non venga terminato correttamente, ma si
3150 blocchi tutto senza la possibilità di avere l'emissione di un segmento FIN che
3151 segnala la terminazione della connessione.
3153 Di nuovo fintanto che la connessione non si riattiva (con il riavvio della
3154 macchina del server) il client non è in grado di fare altro che accettare
3155 dell'input e tentare di inviarlo. La differenza in questo caso è che non
3156 appena la connessione ridiventa attiva i dati verranno sì trasmessi, ma
3157 essendo state perse tutte le informazioni relative alle precedenti connessioni
3158 ai tentativi di scrittura del client sarà risposto con un segmento RST che
3159 provocherà il ritorno di \func{select} per la ricezione di un errore di
3160 \errcode{ECONNRESET}.
3163 \subsection{La funzione \func{shutdown}}
3164 \label{sec:TCP_shutdown}
3166 Come spiegato in sez.~\ref{sec:TCP_conn_term} il procedimento di chiusura di
3167 un socket TCP prevede che da entrambe le parti venga emesso un segmento FIN. È
3168 pertanto del tutto normale dal punto di vista del protocollo che uno dei due
3169 capi chiuda la connessione quando l'altro capo la lascia aperta; abbiamo
3170 incontrato questa situazione nei vari scenari critici di
3171 sez.~\ref{sec:TCP_echo_critical}.
3173 \itindbeg{half-close}
3175 È pertanto possibile avere una situazione in cui un capo della connessione,
3176 non avendo più nulla da scrivere, possa chiudere il socket, segnalando così
3177 l'avvenuta terminazione della trasmissione (l'altro capo riceverà infatti un
3178 \textit{end-of-file} in lettura) mentre dall'altra parte si potrà proseguire
3179 la trasmissione dei dati scrivendo sul socket che da quel lato è ancora
3180 aperto. Questa è quella situazione in cui si dice che il socket è
3181 \textsl{mezzo chiuso} (``\textit{half closed}'').
3183 Il problema che si pone è che se la chiusura del socket è effettuata con la
3184 funzione \func{close}, come spiegato in sez.~\ref{sec:TCP_func_close}, si
3185 perde ogni possibilità di poter leggere quanto l'altro capo può star
3186 continuando a scrivere. Per permettere di segnalare che si è finito con la
3187 scrittura, continuando al contempo a leggere quanto può provenire dall'altro
3188 capo del socket, si può usare la funzione \funcd{shutdown}, il cui prototipo
3192 \fhead{sys/socket.h}
3193 \fdecl{int shutdown(int sockfd, int how)}
3194 \fdesc{Chiude un lato della connessione fra due socket.}
3197 {La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
3198 caso \var{errno} assumerà uno dei valori:
3200 \item[\errcode{EBADF}] \param{sockfd} non è un file descriptor valido.
3201 \item[\errcode{EINVAL}] il valore di \param{how} non è valido.
3202 \item[\errcode{ENOTCONN}] il socket non è connesso.
3203 \item[\errcode{ENOTSOCK}] il file descriptor non corrisponde a un socket.
3207 La funzione prende come primo argomento il socket \param{sockfd} su cui si
3208 vuole operare e come secondo argomento un valore intero \param{how} che indica
3209 la modalità di chiusura del socket, quest'ultima può prendere soltanto tre
3211 \begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
3212 \item[\constd{SHUT\_RD}] chiude il lato in lettura del socket, non sarà più
3213 possibile leggere dati da esso, tutti gli eventuali dati trasmessi
3214 dall'altro capo del socket saranno automaticamente scartati dal kernel, che,
3215 in caso di socket TCP, provvederà comunque ad inviare i relativi segmenti di
3217 \item[\constd{SHUT\_WR}] chiude il lato in scrittura del socket, non sarà più
3218 possibile scrivere dati su di esso. Nel caso di socket TCP la chiamata causa
3219 l'emissione di un segmento FIN, secondo la procedura chiamata
3220 \textit{half-close}. Tutti i dati presenti nel buffer di scrittura prima
3221 della chiamata saranno inviati, seguiti dalla sequenza di chiusura
3222 illustrata in sez.~\ref{sec:TCP_conn_term}.
3223 \item[\constd{SHUT\_RDWR}] chiude sia il lato in lettura che quello in
3224 scrittura del socket. È equivalente alla chiamata in sequenza con
3225 \const{SHUT\_RD} e \const{SHUT\_WR}.
3228 \itindend{half-close}
3230 Ci si può chiedere quale sia l'utilità di avere introdotto \const{SHUT\_RDWR}
3231 quando questa sembra rendere \func{shutdown} del tutto equivalente ad una
3232 \func{close}. In realtà non è così, esiste infatti un'altra differenza con
3233 \func{close}, più sottile. Finora infatti non ci siamo presi la briga di
3234 sottolineare in maniera esplicita che, come per i file e le \textit{fifo},
3235 anche per i socket possono esserci più riferimenti contemporanei ad uno stesso
3238 Per cui si avrebbe potuto avere l'impressione che sia una corrispondenza
3239 univoca fra un socket ed il file descriptor con cui vi si accede. Questo non è
3240 assolutamente vero, (e lo abbiamo già visto nel codice del server di
3241 fig.~\ref{fig:TCP_echo_server_first_code}), ed è invece assolutamente normale
3242 che, come per gli altri oggetti, ci possano essere più file descriptor che
3243 fanno riferimento allo stesso socket.
3245 Allora se avviene uno di questi casi quello che succederà è che la chiamata a
3246 \func{close} darà effettivamente avvio alla sequenza di chiusura di un socket
3247 soltanto quando il numero di riferimenti a quest'ultimo diventerà nullo.
3248 Fintanto che ci sono file descriptor che fanno riferimento ad un socket l'uso
3249 di \func{close} si limiterà a deallocare nel processo corrente il file
3250 descriptor utilizzato, ma il socket resterà pienamente accessibile attraverso
3251 tutti gli altri riferimenti.
3253 Se torniamo all'esempio originale del server di
3254 fig.~\ref{fig:TCP_echo_server_first_code} abbiamo infatti che ci sono due
3255 \func{close}, una sul socket connesso nel padre, ed una sul socket in ascolto
3256 nel figlio, ma queste non effettuano nessuna chiusura reale di detti socket,
3257 dato che restano altri riferimenti attivi, uno al socket connesso nel figlio
3258 ed uno a quello in ascolto nel padre.
3260 Questo non avviene affatto se si usa \func{shutdown} con argomento
3261 \const{SHUT\_RDWR} al posto di \func{close}; in questo caso infatti la
3262 chiusura del socket viene effettuata immediatamente, indipendentemente dalla
3263 presenza di altri riferimenti attivi, e pertanto sarà efficace anche per tutti
3264 gli altri file descriptor con cui, nello stesso o in altri processi, si fa
3265 riferimento allo stesso socket.
3267 Il caso più comune di uso di \func{shutdown} è comunque quello della chiusura
3268 del lato in scrittura, per segnalare all'altro capo della connessione che si è
3269 concluso l'invio dei dati, restando comunque in grado di ricevere quanto
3270 questi potrà ancora inviarci. Questo è ad esempio l'uso che ci serve per
3271 rendere finalmente completo il nostro esempio sul servizio \textit{echo}.
3273 Il nostro client infatti presenta ancora un problema, che nell'uso che finora
3274 ne abbiamo fatto non è emerso, ma che ci aspetta dietro l'angolo non appena
3275 usciamo dall'uso interattivo e proviamo ad eseguirlo redirigendo
3276 \textit{standard input} e \textit{standard output}. Così se eseguiamo:
3278 [piccardi@gont sources]$ \textbf{./echo 192.168.1.1 < ../fileadv.tex > copia}
3281 vedremo che il file \texttt{copia} risulta mancare della parte finale.
3283 Per capire cosa avviene in questo caso occorre tenere presente come avviene la
3284 comunicazione via rete; quando redirigiamo lo \textit{standard input} il
3285 nostro client inizierà a leggere il contenuto del file \texttt{../fileadv.tex}
3286 a blocchi di dimensione massima pari a \texttt{MAXLINE} per poi scriverlo,
3287 alla massima velocità consentitagli dalla rete, sul socket. Dato che la
3288 connessione è con una macchina remota, occorre un certo tempo perché i
3289 pacchetti vi arrivino, vengano processati, e poi tornino
3290 indietro. Considerando trascurabile il tempo di processo, questo tempo è
3291 quello impiegato nella trasmissione via rete, che viene detto RTT (dalla
3292 denominazione inglese \itindex{Round~Trip~Time~(RTT)} \textit{Round Trip
3293 Time}) ed è quello che viene stimato con l'uso del comando \cmd{ping}.
3295 A questo punto, se torniamo al codice mostrato in
3296 fig.~\ref{fig:TCP_ClientEcho_third}, possiamo vedere che mentre i pacchetti
3297 sono in transito sulla rete il client continua a leggere e a scrivere fintanto
3298 che il file in ingresso finisce. Però non appena viene ricevuto un
3299 \textit{end-of-file} in ingresso il nostro client termina. Nel caso
3300 interattivo, in cui si inviavano brevi stringhe una alla volta, c'era sempre
3301 il tempo di eseguire la lettura completa di quanto il server rimandava
3302 indietro. In questo caso invece, quando il client termina, essendo la
3303 comunicazione saturata e a piena velocità, ci saranno ancora pacchetti in
3304 transito sulla rete che devono arrivare al server e poi tornare indietro, ma
3305 siccome il client esce immediatamente dopo la fine del file in ingresso,
3306 questi non faranno a tempo a completare il percorso e verranno persi.
3308 Per evitare questo tipo di problema, invece di uscire una volta completata la
3309 lettura del file in ingresso, occorre usare \func{shutdown} per effettuare la
3310 chiusura del lato in scrittura del socket. In questo modo il client segnalerà
3311 al server la chiusura del flusso dei dati, ma potrà continuare a leggere
3312 quanto il server gli sta ancora inviando indietro, fino a quando anch'esso,
3313 riconosciuta la chiusura del socket in scrittura da parte del client,
3314 effettuerà la chiusura dalla sua parte. Solo alla ricezione della chiusura del
3315 socket da parte del server il client potrà essere sicuro della ricezione di
3316 tutti i dati e della terminazione effettiva della connessione.
3318 \begin{figure}[!htbp]
3319 \footnotesize \centering
3320 \begin{minipage}[c]{\codesamplewidth}
3321 \includecodesample{listati/ClientEcho.c}
3324 \caption{La sezione nel codice della versione finale della funzione
3325 \func{ClientEcho}, che usa \func{shutdown} per una conclusione corretta
3327 \label{fig:TCP_ClientEcho}
3330 Si è allora riportato in fig.~\ref{fig:TCP_ClientEcho} la versione finale
3331 della nostra funzione \func{ClientEcho}, in grado di gestire correttamente
3332 l'intero flusso di dati fra client e server. Il codice completo del client,
3333 comprendente la gestione delle opzioni a riga di comando e le istruzioni per
3334 la creazione della connessione, si trova nel file
3335 \texttt{TCP\_echo\_fourth.c}, distribuito coi sorgenti allegati alla guida.
3337 La nuova versione è molto simile alla precedente di
3338 fig.~\ref{fig:TCP_ClientEcho_third}; la prima differenza è l'introduzione
3339 (\texttt{\small 7}) della variabile \var{eof}, inizializzata ad un valore
3340 nullo, che serve a mantenere traccia dell'avvenuta conclusione della lettura
3341 del file in ingresso.
3343 La seconda modifica (\texttt{\small 12--15}) è stata quella di rendere
3344 subordinata ad un valore nullo di \var{eof} l'impostazione del file descriptor
3345 set per l'osservazione dello \textit{standard input}. Se infatti il valore di
3346 \var{eof} è non nullo significa che si è già raggiunta la fine del file in
3347 ingresso ed è pertanto inutile continuare a tenere sotto controllo lo
3348 \textit{standard input} nella successiva (\texttt{\small 16}) chiamata a
3351 Le maggiori modifiche rispetto alla precedente versione sono invece nella
3352 gestione (\texttt{\small 18--22}) del caso in cui la lettura con \func{fgets}
3353 restituisce un valore nullo, indice della fine del file. Questa nella
3354 precedente versione causava l'immediato ritorno della funzione; in questo caso
3355 prima (\texttt{\small 19}) si imposta opportunamente \var{eof} ad un valore
3356 non nullo, dopo di che (\texttt{\small 20}) si effettua la chiusura del lato
3357 in scrittura del socket con \func{shutdown}. Infine (\texttt{\small 21}) si
3358 usa la macro \macro{FD\_CLR} per togliere lo \textit{standard input} dal
3359 \textit{file descriptor set}.
3361 In questo modo anche se la lettura del file in ingresso è conclusa, la
3362 funzione non esce dal ciclo principale (\texttt{\small 11--50}), ma continua
3363 ad eseguirlo ripetendo la chiamata a \func{select} per tenere sotto controllo
3364 soltanto il socket connesso, dal quale possono arrivare altri dati, che
3365 saranno letti (\texttt{\small 31}) ed opportunamente trascritti
3366 (\texttt{\small 44--48}) sullo \textit{standard output}.
3368 Il ritorno della funzione, e la conseguente terminazione normale del client,
3369 viene invece adesso gestito all'interno (\texttt{\small 30--49}) della lettura
3370 dei dati dal socket; se infatti dalla lettura del socket si riceve una
3371 condizione di \textit{end-of-file}, la si tratterà (\texttt{\small 36--43}) in
3372 maniera diversa a seconda del valore di \var{eof}. Se infatti questa è diversa
3373 da zero (\texttt{\small 37--39}), essendo stata completata la lettura del file
3374 in ingresso, vorrà dire che anche il server ha concluso la trasmissione dei
3375 dati restanti, e si potrà uscire senza errori, altrimenti si stamperà
3376 (\texttt{\small 40--42}) un messaggio di errore per la chiusura precoce della
3380 \subsection{Un server basato sull'\textit{I/O multiplexing}}
3381 \label{sec:TCP_serv_select}
3383 Seguendo di nuovo le orme di Stevens in \cite{UNP1} vediamo ora come con
3384 l'utilizzo dell'\textit{I/O multiplexing} diventi possibile riscrivere
3385 completamente il nostro server \textit{echo} con una architettura
3386 completamente diversa, in modo da evitare di dover creare un nuovo processo
3387 tutte le volte che si ha una connessione.\footnote{ne faremo comunque una
3388 realizzazione diversa rispetto a quella presentata da Stevens in
3391 La struttura del nuovo server è illustrata in
3392 fig.~\ref{fig:TCP_echo_multiplex}, in questo caso avremo un solo processo che
3393 ad ogni nuova connessione da parte di un client sul socket in ascolto si
3394 limiterà a registrare l'entrata in uso di un nuovo file descriptor ed
3395 utilizzerà \func{select} per rilevare la presenza di dati in arrivo su tutti i
3396 file descriptor attivi, operando direttamente su ciascuno di essi.
3398 \begin{figure}[!htb]
3399 \centering \includegraphics[width=13cm]{img/TCPechoMult}
3400 \caption{Schema del nuovo server echo basato sull'\textit{I/O multiplexing}.}
3401 \label{fig:TCP_echo_multiplex}
3404 La sezione principale del codice del nuovo server è illustrata in
3405 fig.~\ref{fig:TCP_SelectEchod}. Si è tralasciata al solito la gestione delle
3406 opzioni, che è identica alla versione precedente. Resta invariata anche tutta
3407 la parte relativa alla gestione dei segnali, degli errori, e della cessione
3408 dei privilegi, così come è identica la gestione della creazione del socket (si
3409 può fare riferimento al codice già illustrato in
3410 sez.~\ref{sec:TCPsimp_server_main}); al solito il codice completo del server è
3411 disponibile coi sorgenti allegati nel file \texttt{select\_echod.c}.
3413 \begin{figure}[!htbp]
3414 \footnotesize \centering
3415 \begin{minipage}[c]{\codesamplewidth}
3416 \includecodesample{listati/select_echod.c}
3419 \caption{La sezione principale della nuova versione di server
3420 \textit{echo} basato sull'uso della funzione \func{select}.}
3421 \label{fig:TCP_SelectEchod}
3424 In questo caso, una volta aperto e messo in ascolto il socket, tutto quello
3425 che ci servirà sarà chiamare \func{select} per rilevare la presenza di nuove
3426 connessioni o di dati in arrivo, e processarli immediatamente. Per realizzare
3427 lo schema mostrato in fig.~\ref{fig:TCP_echo_multiplex} il programma usa una
3428 tabella dei socket connessi mantenuta nel vettore \var{fd\_open} dimensionato
3429 al valore di \const{FD\_SETSIZE}, ed una variabile \var{max\_fd} per
3430 registrare il valore più alto dei file descriptor aperti.
3432 Prima di entrare nel ciclo principale (\texttt{\small 5--53}) la nostra
3433 tabella viene inizializzata (\texttt{\small 2}) a zero (valore che
3434 utilizzeremo come indicazione del fatto che il relativo file descriptor non è
3435 aperto), mentre il valore massimo (\texttt{\small 3}) per i file descriptor
3436 aperti viene impostato a quello del socket in ascolto, in quanto esso è
3437 l'unico file aperto, oltre i tre standard, e pertanto avrà il valore più alto,
3438 che verrà anche (\texttt{\small 4}) inserito nella tabella.
3440 La prima sezione (\texttt{\small 6--8}) del ciclo principale esegue la
3441 costruzione del \textit{file descriptor set} \var{fset} in base ai socket
3442 connessi in un certo momento; all'inizio ci sarà soltanto il socket in ascolto
3443 ma nel prosieguo delle operazioni verranno utilizzati anche tutti i socket
3444 connessi registrati nella tabella \var{fd\_open}. Dato che la chiamata di
3445 \func{select} modifica il valore del \textit{file descriptor set} è necessario
3446 ripetere (\texttt{\small 6}) ogni volta il suo azzeramento per poi procedere
3447 con il ciclo (\texttt{\small 7--8}) in cui si impostano i socket trovati
3450 Per far questo si usa la caratteristica dei file descriptor, descritta in
3451 sez.~\ref{sec:file_open_close}, per cui il kernel associa sempre ad ogni nuovo
3452 file il file descriptor con il valore più basso disponibile. Questo fa sì che
3453 si possa eseguire il ciclo (\texttt{\small 7}) a partire da un valore minimo,
3454 che sarà sempre quello del socket in ascolto, mantenuto in \var{list\_fd},
3455 fino al valore massimo di \var{max\_fd} che dovremo aver cura di tenere
3456 aggiornato. Dopo di che basterà controllare (\texttt{\small 8}) nella nostra
3457 tabella se il file descriptor è in uso o meno,\footnote{si tenga presente che
3458 benché il kernel assegni sempre il primo valore libero, si potranno sempre
3459 avere dei \textsl{buchi} nella nostra tabella dato che nelle operazioni i
3460 socket saranno aperti e chiusi in corrispondenza della creazione e
3461 conclusione delle connessioni.} e impostare \var{fset} di conseguenza.
3463 Una volta inizializzato con i socket aperti il nostro \textit{file descriptor
3464 set} potremo chiamare \func{select} per fargli osservare lo stato degli
3465 stessi (in lettura, presumendo che la scrittura sia sempre consentita). Come
3466 per il precedente esempio di sez.~\ref{sec:TCP_child_hand}, essendo questa
3467 l'unica funzione che può bloccarsi ed essere interrotta da un segnale, la
3468 eseguiremo (\texttt{\small 9--10}) all'interno di un ciclo di \code{while},
3469 che la ripete indefinitamente qualora esca con un errore di \errcode{EINTR}.
3470 Nel caso invece di un errore normale si provvede (\texttt{\small 11--14}) ad
3471 uscire dal programma stampando un messaggio di errore.
3473 Infine quando la funzione ritorna normalmente avremo in \var{n} il numero di
3474 socket da controllare. Nello specifico si danno due casi per cui \func{select}
3475 può ritornare: o si è ricevuta una nuova connessione ed è pronto il socket in
3476 ascolto, sul quale si può eseguire \func{accept}, o c'è attività su uno dei
3477 socket connessi, sui quali si può eseguire \func{read}.
3479 Il primo caso viene trattato immediatamente (\texttt{\small 15--24}): si
3480 controlla (\texttt{\small 15}) che il socket in ascolto sia fra quelli attivi,
3481 nel qual caso anzitutto (\texttt{\small 16}) se ne decrementa il numero
3482 mantenuto nella variabile \var{n}. Poi, inizializzata (\texttt{\small 17}) la
3483 lunghezza della struttura degli indirizzi, si esegue \func{accept} per
3484 ottenere il nuovo socket connesso, controllando che non ci siano errori
3485 (\texttt{\small 18--21}). In questo caso non c'è più la necessità di
3486 controllare per interruzioni dovute a segnali, in quanto siamo sicuri che
3487 \func{accept} non si bloccherà. Per completare la trattazione occorre a questo
3488 punto aggiungere (\texttt{\small 22}) il nuovo file descriptor alla tabella di
3489 quelli connessi, ed inoltre, se è il caso, aggiornare (\texttt{\small 23}) il
3490 valore massimo in \var{max\_fd}.
3492 Una volta controllato l'arrivo di nuove connessioni si passa a verificare se
3493 ci sono dati sui socket connessi, per questo si ripete un ciclo
3494 (\texttt{\small 26--52}) fintanto che il numero di socket attivi indicato
3495 dalla variabile \var{n} resta diverso da zero. In questo modo, se l'unico
3496 socket con attività era quello connesso, avendola opportunamente decrementata
3497 in precedenza, essa risulterà nulla, pertanto il ciclo di verifica verrà
3498 saltato e si ritornerà all'inzizio del ciclo principale, ripetendo, dopo
3499 l'inizializzazione del \textit{file descriptor set} con i nuovi valori nella
3500 tabella, la chiamata di \func{select}.
3502 Se il socket attivo non è quello in ascolto, o ce ne sono comunque anche
3503 altri, il valore di \var{n} non sarà nullo ed il controllo sarà
3504 eseguito. Prima di entrare nel ciclo di veridica comunque si inizializza
3505 (\texttt{\small 25}) il valore della variabile \var{i}, che useremo come
3506 indice nella tabella \var{fd\_open}, al valore minimo, corrispondente al file
3507 descriptor del socket in ascolto.
3509 Il primo passo (\texttt{\small 27}) nella verifica è incrementare il valore
3510 dell'indice \var{i} per posizionarsi sul primo valore possibile per un file
3511 descriptor associato ad un eventuale socket connesso, dopo di che si controlla
3512 (\texttt{\small 28}) se questo è nella tabella dei socket connessi, chiedendo
3513 la ripetizione del ciclo in caso contrario. Altrimenti si passa a verificare
3514 (\texttt{\small 29}) se il file descriptor corrisponde ad uno di quelli
3515 attivi, e nel caso si esegue (\texttt{\small 30}) una lettura, uscendo con un
3516 messaggio in caso di errore (\texttt{\small 31--35}).
3518 Se (\texttt{\small 36}) il numero di byte letti \var{nread} è nullo si è in
3519 presenza di una \textit{end-of-file}, indice che una connessione che si è
3520 chiusa, che deve essere trattata (\texttt{\small 36--45}) opportunamente. Il
3521 primo passo è chiudere (\texttt{\small 37}) anche il proprio capo del socket e
3522 rimuovere (\texttt{\small 38}) il file descriptor dalla tabella di quelli
3523 aperti, inoltre occorre verificare (\texttt{\small 39}) se il file descriptor
3524 chiuso è quello con il valore più alto, nel qual caso occorre trovare
3525 (\texttt{\small 39--43}) il nuovo massimo, altrimenti (\texttt{\small 44}) si
3526 può ripetere il ciclo da capo per esaminare (se ne restano) ulteriori file
3529 Se però è stato chiuso il file descriptor più alto, dato che la scansione dei
3530 file descriptor attivi viene fatta a partire dal valore più basso, questo
3531 significa che siamo anche arrivati alla fine della scansione, per questo
3532 possiamo utilizzare direttamente il valore dell'indice \var{i} con un ciclo
3533 all'indietro (\texttt{\small 40}) che trova il primo valore per cui la tabella
3534 presenta un file descriptor aperto, e lo imposta (\texttt{\small 41}) come
3535 nuovo massimo, per poi tornare (\texttt{\small 42}) al ciclo principale con un
3536 \code{break}, e rieseguire \func{select}.
3538 Se infine si sono effettivamente letti dei dati dal socket (ultimo caso
3539 rimasto) si potrà invocare immediatamente (\texttt{\small 46})
3540 \func{FullWrite} per riscriverli indietro sul socket stesso, avendo cura di
3541 uscire con un messaggio in caso di errore (\texttt{\small 47--50}). Si noti
3542 che nel ciclo si esegue una sola lettura, contrariamente a quanto fatto con la
3543 precedente versione (si riveda il codice di fig.~\ref{fig:TCP_ServEcho_second})
3544 in cui si continuava a leggere fintanto che non si riceveva un
3545 \textit{end-of-file}, questo perché usando l'\textit{I/O multiplexing} non si
3546 vuole essere bloccati in lettura.
3548 L'uso di \func{select} ci permette di trattare automaticamente anche il caso
3549 in cui la \func{read} non è stata in grado di leggere tutti i dati presenti
3550 sul socket, dato che alla iterazione successiva \func{select} ritornerà
3551 immediatamente segnalando l'ulteriore disponibilità.
3553 Il nostro server comunque soffre di una vulnerabilità per un attacco di tipo
3554 \textit{Denial of Service}. Il problema è che in caso di blocco di una
3555 qualunque delle funzioni di I/O, non avendo usato processi separati, tutto il
3556 server si ferma e non risponde più a nessuna richiesta. Abbiamo scongiurato
3557 questa evenienza per l'I/O in ingresso con l'uso di \func{select}, ma non vale
3558 altrettanto per l'I/O in uscita. Il problema pertanto può sorgere qualora una
3559 delle chiamate a \func{write} effettuate da \func{FullWrite} si blocchi.
3561 Con il funzionamento normale questo non accade in quanto il server si limita a
3562 scrivere quanto riceve in ingresso, ma qualora venga utilizzato un client
3563 malevolo che esegua solo scritture e non legga mai indietro l'\textsl{eco} del
3564 server, si potrebbe giungere alla saturazione del buffer di scrittura, ed al
3565 conseguente blocco del server su di una \func{write}.
3567 Le possibili soluzioni in questo caso sono quelle di ritornare ad eseguire il
3568 ciclo di risposta alle richieste all'interno di processi separati, utilizzare
3569 un timeout per le operazioni di scrittura, o eseguire queste ultime in
3570 modalità non bloccante, concludendo le operazioni qualora non vadano a buon
3574 \subsection{\textit{I/O multiplexing} con \func{poll}}
3575 \label{sec:TCP_serv_poll}
3577 Finora abbiamo trattato le problematiche risolubili con l'\textit{I/O
3578 multiplexing} impiegando la funzione \func{select}. Questo è quello che
3579 avviene nella maggior parte dei casi, in quanto essa è nata sotto BSD proprio
3580 per affrontare queste problematiche con i socket. Abbiamo però visto in
3581 sez.~\ref{sec:file_multiplexing} come la funzione \func{poll} possa costituire
3582 una alternativa a \func{select}, con alcuni vantaggi, non soffrendo delle
3583 limitazioni dovute all'uso dei \textit{file descriptor set}.
3585 Ancora una volta in sez.~\ref{sec:file_poll} abbiamo trattato la funzione in
3586 maniera generica, parlando di file descriptor, ma come per \func{select}
3587 quando si ha a che fare con dei socket, il concetto di essere \textsl{pronti}
3588 per l'I/O deve essere specificato nei dettagli per tener conto delle
3589 condizioni della rete. Inoltre deve essere specificato come viene classificato
3590 il traffico nella suddivisione fra dati normali e prioritari. In generale
3593 \item i dati inviati su un socket vengono considerati traffico normale,
3594 pertanto vengono rilevati alla loro ricezione sull'altro capo da una
3595 selezione effettuata con \const{POLLIN} o \const{POLLRDNORM};
3596 \item i dati urgenti \textit{out-of-band} (vedi
3597 sez.~\ref{sec:TCP_urgent_data}) su un socket TCP vengono considerati
3598 traffico prioritario e vengono rilevati da una condizione \const{POLLIN},
3599 \const{POLLPRI} o \const{POLLRDBAND}.
3600 \item la chiusura di una connessione (cioè la ricezione di un segmento FIN)
3601 viene considerato traffico normale, pertanto viene rilevato da una
3602 condizione \const{POLLIN} o \const{POLLRDNORM}, ma una conseguente chiamata
3603 a \func{read} restituirà 0.
3604 \item la disponibilità di spazio sul socket per la scrittura di dati viene
3605 segnalata con una condizione \const{POLLOUT}.
3606 \item quando uno dei due capi del socket chiude un suo lato della connessione
3607 con \func{shutdown} si riceve una condizione di \const{POLLHUP}.
3608 \item la presenza di un errore sul socket (sia dovuta ad un segmento RST che a
3609 timeout) viene considerata traffico normale, ma viene segnalata anche dalla
3610 condizione \const{POLLERR}.
3611 \item la presenza di una nuova connessione su un socket in ascolto può essere
3612 considerata sia traffico normale che prioritario, nel caso di Linux la
3613 realizzazione dello \textit{stack TCP} la classifica come normale.
3616 Come esempio dell'uso di \func{poll} proviamo allora a riscrivere il server
3617 \textit{echo} secondo lo schema di fig.~\ref{fig:TCP_echo_multiplex} usando
3618 \func{poll} al posto di \func{select}. In questo caso dovremo fare qualche
3619 modifica, per tenere conto della diversa sintassi delle due funzioni, ma la
3620 struttura del programma resta sostanzialmente la stessa.
3623 \begin{figure}[!htbp]
3624 \footnotesize \centering
3625 \begin{minipage}[c]{\codesamplewidth}
3626 \includecodesample{listati/poll_echod.c}
3629 \caption{La sezione principale della nuova versione di server
3630 \textit{echo} basato sull'uso della funzione \func{poll}.}
3631 \label{fig:TCP_PollEchod}
3634 In fig.~\ref{fig:TCP_PollEchod} è riportata la sezione principale della nuova
3635 versione del server, la versione completa del codice è riportata nel file
3636 \texttt{poll\_echod.c} dei sorgenti allegati alla guida. Al solito nella
3637 figura si sono tralasciate la gestione delle opzioni, la creazione del socket
3638 in ascolto, la cessione dei privilegi e le operazioni necessarie a far
3639 funzionare il programma come demone, privilegiando la sezione principale del
3642 Come per il precedente server basato su \func{select} il primo passo
3643 (\texttt{\small 2--8}) è quello di inizializzare le variabili necessarie. Dato
3644 che in questo caso dovremo usare un vettore di strutture occorre anzitutto
3645 (\texttt{\small 2}) allocare la memoria necessaria utilizzando il numero
3646 massimo \var{n} di socket osservabili, che viene impostato attraverso
3647 l'opzione \texttt{-n} ed ha un valore di default di 256.
3649 Dopo di che si preimposta (\texttt{\small 3}) il valore \var{max\_fd} del file
3650 descriptor aperto con valore più alto a quello del socket in ascolto (al
3651 momento l'unico), e si provvede (\texttt{\small 4--7}) ad inizializzare le
3652 strutture, disabilitando l'osservazione (\texttt{\small 5}) con un valore
3653 negativo del campo \var{fd}, ma predisponendo (\texttt{\small 6}) il campo
3654 \var{events} per l'osservazione dei dati normali con \const{POLLRDNORM}.
3655 Infine (\texttt{\small 8}) si attiva l'osservazione del socket in ascolto
3656 inizializzando la corrispondente struttura. Questo metodo comporta, in
3657 modalità interattiva, lo spreco di tre strutture (quelle relative a
3658 \textit{standard input}, \textit{standard output} e \textit{standard error})
3659 che non vengono mai utilizzate in quanto la prima è sempre quella relativa al
3662 Una volta completata l'inizializzazione tutto il lavoro viene svolto
3663 all'interno del ciclo principale \texttt{\small 9--53}) che ha una struttura
3664 sostanzialmente identica a quello usato per il precedente esempio basato su
3665 \func{select}. La prima istruzione (\texttt{\small 10}) è quella di eseguire
3666 \func{poll} all'interno di un ciclo che la ripete qualora venisse interrotta
3667 da un segnale, da cui si esce soltanto quando la funzione ritorna restituendo
3668 nella variabile \var{n} il numero di file descriptor trovati attivi. Qualora
3669 invece si sia ottenuto un errore si procede (\texttt{\small 11--14}) alla
3670 terminazione immediata del processo provvedendo a stampare una descrizione
3673 Una volta ottenuta dell'attività su un file descriptor si hanno di nuovo due
3674 possibilità. La prima è che ci sia attività sul socket in ascolto, indice di
3675 una nuova connessione, nel qual caso si controlla (\texttt{\small 17}) se il
3676 campo \var{revents} della relativa struttura è attivo; se è così si provvede
3677 (\texttt{\small 16}) a decrementare la variabile \var{n} (che assume il
3678 significato di numero di file descriptor attivi rimasti da controllare) per
3679 poi (\texttt{\small 17--21}) effettuare la chiamata ad \func{accept},
3680 terminando il processo in caso di errore. Se la chiamata ad \func{accept} ha
3681 successo si procede attivando (\texttt{\small 22}) la struttura relativa al
3682 nuovo file descriptor da essa ottenuto, modificando (\texttt{\small 23})
3683 infine quando necessario il valore massimo dei file descriptor aperti
3684 mantenuto in \var{max\_fd}.
3686 La seconda possibilità è che vi sia dell'attività su uno dei socket aperti in
3687 precedenza, nel qual caso si inizializza (\texttt{\small 25}) l'indice \var{i}
3688 del vettore delle strutture \struct{pollfd} al valore del socket in ascolto,
3689 dato che gli ulteriori socket aperti avranno comunque un valore superiore. Il
3690 ciclo (\texttt{\small 26--52}) prosegue fintanto che il numero di file
3691 descriptor attivi, mantenuto nella variabile \var{n}, è diverso da zero. Se
3692 pertanto ci sono ancora socket attivi da individuare si comincia con
3693 l'incrementare (\texttt{\small 27}) l'indice e controllare (\texttt{\small
3694 28}) se corrisponde ad un file descriptor in uso analizzando il valore del
3695 campo \var{fd} della relativa struttura e chiudendo immediatamente il ciclo
3696 qualora non lo sia. Se invece il file descriptor è in uso si verifica
3697 (\texttt{\small 29}) se c'è stata attività controllando il campo
3700 Di nuovo se non si verifica la presenza di attività il ciclo si chiude subito,
3701 altrimenti si provvederà (\texttt{\small 30}) a decrementare il numero \var{n}
3702 di file descriptor attivi da controllare e ad eseguire (\texttt{\small 31}) la
3703 lettura, ed in caso di errore (\texttt{\small 32--35}) al solito lo si
3704 notificherà uscendo immediatamente. Qualora invece si ottenga una condizione
3705 di \textit{end-of-file} (\texttt{\small 36--45}) si provvederà a chiudere
3706 (\texttt{\small 37}) anche il nostro capo del socket e a marcarlo
3707 (\texttt{\small 38}) come inutilizzato nella struttura ad esso associata.
3708 Infine dovrà essere ricalcolato (\texttt{\small 39--43}) un eventuale nuovo
3709 valore di \var{max\_fd}. L'ultimo passo è chiudere (\texttt{\small 44}) il
3710 ciclo in quanto in questo caso non c'è più niente da riscrivere all'indietro
3713 Se invece si sono letti dei dati si provvede (\texttt{\small 46}) ad
3714 effettuarne la riscrittura all'indietro, con il solito controllo ed eventuale
3715 uscita e notifica in caso di errore (\texttt{\small 47--51}).
3717 Come si può notare la logica del programma è identica a quella vista in
3718 fig.~\ref{fig:TCP_SelectEchod} per l'analogo server basato su \func{select};
3719 la sola differenza significativa è che in questo caso non c'è bisogno di
3720 rigenerare i \textit{file descriptor set} in quanto l'uscita è indipendente
3721 dai dati in ingresso. Si applicano comunque anche a questo server le
3722 considerazioni finali di sez.~\ref{sec:TCP_serv_select}.
3725 %\subsection{\textit{I/O multiplexing} con \textit{epoll}}
3726 %\label{sec:TCP_serv_epoll}
3730 % TODO fare esempio con epoll
3734 % LocalWords: socket TCP client dell'I multiplexing stream three way handshake
3735 % LocalWords: header stack kernel SYN ACK URG syncronize sez bind listen fig
3736 % LocalWords: accept connect active acknowledge l'acknowledge nell'header MSS
3737 % LocalWords: sequence number l'acknowledgement dell'header options l'header
3738 % LocalWords: option MMS segment size MAXSEG window advertised Mbit sec nell'
3739 % LocalWords: timestamp RFC long fat close of l'end l'ACK half shutdown CLOSED
3740 % LocalWords: netstat SENT ESTABLISHED WAIT IPv Ethernet piggybacking UDP MSL
3741 % LocalWords: l'overhead Stevens Lifetime router hop limit TTL to live RST SSH
3742 % LocalWords: routing dell'MSL l'IP multitasking well known port ephemeral BSD
3743 % LocalWords: ports dall' IANA Assigned Authority like glibc netinet IPPORT AF
3744 % LocalWords: RESERVED USERRESERVED rsh rlogin pair socketpair Local Address
3745 % LocalWords: Foreing DNS caching INADDR ANY multihoming loopback ssh fuser ip
3746 % LocalWords: lsof SOCK sys int sockfd const struct sockaddr serv addr socklen
3747 % LocalWords: addrlen errno EBADF descriptor EINVAL ENOTSOCK EACCES EADDRINUSE
3748 % LocalWords: EADDRNOTAVAIL EFAULT ENOTDIR ENOENT ENOMEM ELOOP ENOSR EROFS RPC
3749 % LocalWords: portmapper htonl tab endianness BROADCAST broadcast any extern fd
3750 % LocalWords: ADRR INIT DGRAM SEQPACKET servaddr ECONNREFUSED ETIMEDOUT EAGAIN
3751 % LocalWords: ENETUNREACH EINPROGRESS EALREADY EAFNOSUPPORT EPERM EISCONN proc
3752 % LocalWords: sysctl filesystem syn retries reset ICMP backlog EOPNOTSUPP RECV
3753 % LocalWords: connection queue dell'ACK flood spoofing syncookies SOMAXCONN CR
3754 % LocalWords: RDM EWOULDBLOCK firewall ENOBUFS EINTR EMFILE ECONNABORTED NULL
3755 % LocalWords: ESOCKTNOSUPPORT EPROTONOSUPPORT ERESTARTSYS connected listening
3756 % LocalWords: DECnet read write NONBLOCK fcntl getsockname getpeername name ps
3757 % LocalWords: namelen namlen ENOTCONN exec inetd POSIX daytime FullRead count
3758 % LocalWords: BUF FullWrite system call INET perror htons inet pton ctime FTP
3759 % LocalWords: fputs carriage return line feed superdemone daytimed sleep fork
3760 % LocalWords: daemon cunc logging list conn sock exit snprintf ntop ntohs echo
3761 % LocalWords: crash superserver L'RFC first ClientEcho stdin stdout fgets main
3762 % LocalWords: MAXLINE initd echod ServEcho setgid short nogroup nobody setuid
3763 % LocalWords: demonize PrintErr syslog wrapper log error root RTT EOF ctrl ack
3764 % LocalWords: while SIGCHLD Signal RESTART sigaction SignalRestart SigHand win
3765 % LocalWords: flags select recvfrom debug second compat waiting Nsec ENETDOWN
3766 % LocalWords: EPROTO ENOPROTOOPT EHOSTDOWN ENONET EHOSTUNREACH LINGER tcpdump
3767 % LocalWords: ECONNRESET advertising PSH SIGTERM strace SIGPIPE gets tcp ARP
3768 % LocalWords: cache anarres destination unreachable l'I low watermark RCVLOWAT
3769 % LocalWords: SNDLOWAT third fset maxfd fileno ISSET closed how SHUT RD WR eof
3770 % LocalWords: RDWR fifo Trip ping fourth CLR sull'I SETSIZE nread break Denial
3771 % LocalWords: Service poll POLLIN POLLRDNORM POLLPRI POLLRDBAND POLLOUT events
3772 % LocalWords: POLLHUP POLLERR revents pollfd Di scaling SYNCNT DoS
3774 %%% Local Variables:
3776 %%% TeX-master: "gapil"