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