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