elemtcp.tex

   1 \chapter{Socket TCP elementari}
   2 \label{cha:elem_TCP_sock}
   3
   4 In questo capitolo inizieremo ad approndire la conoscenza dei socket TCP,
   5 tratteremo qui dunque il funzionamento delle varie funzioni che si sono usate
   6 nei due esempi elementari forniti in precedenza (vedi
   7 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}), previa una
   8 descrizione delle principali caratteristiche del funzionamento di una
   9 connessione TCP.
  10
  11 La seconda parte del capitolo sarà poi dedicata alla scrittura di una prima
  12 semplice applicazione client/server completa, che implementi il servizio
  13 standard \texttt{echo} su TCP.
  14
  15 \section{Il funzionamento di una connessione TCP}
  16 \label{sec:TCPel_connession}
  17
  18 Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
  19 utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
  20 del TCP, la conoscenza del funzionamento del protocollo è infatti essenziale
  21 per capire il modello di programmazione ed il funzionamento delle API.
  22
  23 In particolare ci concentreremo sulle modalità con le quali il protocollo da
  24 inizio e conclude una connessione; faremo anche un breve accenno al
  25 significato di alcuni dei vari stati che il protocollo assume durante la vita
  26 di una connessione, che possono essere osservati per ciascun socket attivo con
  27 l'uso del programma \texttt{netstat}.
  28
  29 \subsection{La creazione della connessione: il \textit{three way handushake}}
  30 \label{sec:TCPel_conn_cre}
  31
  32 Il processo che porta a creare una connessione TCP è chiamato \textit{three
  33   way handushake}; la successione tipica degli eventi (la stessa che si
  34 verifica utilizzando il codice dei due precedenti esempi elementari
  35 \figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
  36 creazione di una connessione è la seguente:
  37
  38 \begin{itemize}
  39 \item Il server deve essere preparato per accettare le connessioni in arrivo;
  40   il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
  41   \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
  42   \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
  43   passiva il server chiama la funzione \texttt{accept} e il processo si blocca
  44   in attesa di connessioni.
  45
  46 \item Il client richiede l'inizio della connessione usando la funzione
  47   \texttt{connect}, attraverso un procedimento che viene chiamato
  48   \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
  49   \texttt{connect} blocca il processo e causa l'invio da parte del client di
  50   un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
  51     elementare di dati trasmessa dal protocollo TCP al livello superiore;
  52     tutti i segmenti hanno un header che contiene le informazioni che servono
  53     allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
  54     che implementa il protocollo) per realizzare la comunicazione, fra questi
  55     dati ci sono una serie di flag usati per gestire la connessione, come
  56     \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
  57     come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a
  58     funzioni particolari del protocollo e danno il nome al segmento, (per
  59     maggiori dettagli vedere \capref{cha:tcp_protocol})}, in sostanza viene
  60   inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
  61   il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
  62
  63 \item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
  64   del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
  65   client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
  66   ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
  67   \texttt{ACK} e sono settati.
  68
  69 \item una volta che il client ha ricevuto l'acknowledge dal server la funzione
  70   \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
  71   \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
  72   quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
  73   è stabilita.
  74 \end{itemize}
  75
  76 Il procedimento viene chiamato \textit{three way handshake} dato che per
  77 realizzarlo devono essere scambiati tre segmenti.  In \nfig\ si è
  78 rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce
  79 la connessione.
  80
  81 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
  82 % sistema del telefono. La funzione \texttt{socket} può essere considerata
  83 % l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al
  84 % dire alle altre persone qual'è il proprio numero di telefono perché possano
  85 % chiamare. La funzione \texttt{listen} è accendere il campanello del telefono
  86 % per sentire le chiamate in arrivo.  La funzione \texttt{connect} richiede di
  87 % conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è
  88 % quando si risponde al telefono.
  89
  90 \begin{figure}[htb]
  91   \centering
  92
  93   \caption{Il \textit{three way handshake} del TCP}
  94   \label{fig:TCPel_TWH}
  95 \end{figure}
  96
  97 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
  98 riportati in \curfig); per gestire una connessione affidabile infatti il
  99 protocollo TCP prevede nell'header la presenza di un numero a 32 bit (chiamato
 100 appunto \textit{sequence number}) che identifica a quale byte nella sequenza
 101 del flusso corrisponde il primo byte della sezione dati contenuta nel
 102 segmento.
 103
 104 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
 105 \textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
 106 all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
 107 ciascun segmento viene effettuato dall'altro capo della connessione settando
 108 il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
 109 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
 110 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
 111 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
 112 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
 113 varrà anche (vedi \nfig) per l'acknowledgement di un FIN.
 114
 115 \subsection{Le opzioni TCP.}
 116 \label{sec:TCPel_TCP_opt}
 117
 118 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
 119 (le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
 120 dati) che servono a comunicare all'altro capo una serie di parametri utili a
 121 regolare la connessione. Normalmente vengono usate le seguenti opzioni:
 122
 123 \begin{itemize}
 124 \item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
 125   opzione ciascun capo della connessione annuncia all'altro il massimo
 126   ammontare di dati che vorrebbe accettare per ciascun segmento nella
 127   connesione corrente. È possibile leggere e scrivere questo valore attraverso
 128   l'opzione del socket \texttt{TCP\_MAXSEG}.
 129
 130 \item \textit{window scale option} come spiegato in \capref{cha:tcp_protocol} il
 131   protocollo TCP implementa il controllo di flusso attraverso una
 132   \textsl{finestra annunciata} (\textit{advertized window}) con la quale
 133   ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
 134   memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può
 135   indicare un massimo di 65535 bytes (anche se linux usa come massimo 32767
 136   per evitare problemi con alcuni stack bacati che usano l'aritmetica con
 137   segno per implementare lo stack TCP); ma alcuni tipi di connessione come
 138   quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
 139   ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
 140   più grande per poter ottenere il massimo dalla trasmissione, per questo
 141   esiste questa opzione che indica un fattore di scala da applicare al valore
 142   della finestra annunciata\footnote{essendo una nuova opzione per garantire
 143     la compatibilità con delle vecchie implementazioni del protocollo la
 144     procedura che la attiva prevede come negoziazione che l'altro capo della
 145     connessione riconosca esplicitamente l'opzione inserendola anche lui nel
 146     suo SYN di risposta dell'apertura della connessione} per la connessione
 147   corrente (espresso come numero di bit cui shiftare a sinistra il valore
 148   della finestra annunciata inserito nel pacchetto).
 149
 150 \item \textit{timestamp option} è anche questa una nuova opzione necessaria
 151   per le connessioni ad alta velocità per evitare possibili corruzioni di dati
 152   dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
 153   la precedente.
 154
 155 \end{itemize}
 156
 157 La MSS è generalmente supportata da quasi tutte le implementazioni del
 158 protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
 159 vengono anche dette \textit{long fat pipe options} dato che questo è il nome
 160 che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
 161 elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
 162
 163 \subsection{La terminazione della connessione}
 164 \label{sec:TCPel_conn_term}
 165
 166 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
 167 procedura di chiusura ne richede quattro; ancora una volta si può fare
 168 riferimento al codice degli esempi \figref{fig:net_cli_code} e
 169 \figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
 170 seguente:
 171
 172 \begin{enumerate}
 173 \item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
 174   l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da
 175   \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
 176   significa che si è finito con l'invio dei dati sulla connessione.
 177
 178 \item L'altro capo della connessione riceve il FIN ed esegue la
 179   \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
 180   tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
 181   viene passato al processo che ha aperto il socket come un end of file sulla
 182   lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
 183   ricevuto), dato che il ricevimento di un FIN significa che non si
 184   riceveranno altri dati sulla connessione.
 185
 186 \item Dopo un certo tempo anche il secondo processo chiamerà la funzione
 187   \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
 188   FIN.
 189
 190 \item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
 191   con un ACK.
 192 \end{enumerate}
 193
 194
 195 Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
 196 normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
 197 sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
 198 detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
 199 accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
 200 sequenza di scambio dei segmenti che stabilisce la connessione.
 201
 202 \begin{figure}[htb]
 203   \centering
 204
 205   \caption{Il \textit{three way handshake} del TCP}
 206   \label{fig:TCPel_TWH}
 207 \end{figure}
 208
 209 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
 210 l'ACK riporterà un \textit{acknowledge number} incrementato di uno.
 211
 212 Si noti che nella sequenza di chiusura fra i passi 2 e 3 è in teoria possibile
 213 che si mantenga un flusso di dati dal capo della connessione che sta eseguendo
 214 la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella
 215 sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma
 216 esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato
 217 \textit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
 218 più avanti, quando parleremo della funzione \texttt{shutdown}.
 219
 220 La emissione del FIN avviene quando il socket viene chiuso, questo però non
 221 avviene solo per la chiamata della funzione \texttt{close} (come in
 222 \figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
 223 in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
 224 viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
 225
 226 Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
 227 in \secref{sec:TCPel_echo_example}) sia il client ad eseguire la chiusura
 228 attiva, nella realtà questa può essere eseguita da uno qualunque dei due capi
 229 della comunicazione (come in fatto in precedenza da
 230 \figref{fig:net_serv_code}), e benché quello del client sia il caso più comune
 231 ci sono alcuni servizi, il principale dei quali è l'HTTP, per i quali è il
 232 server ad effettuare la chiusura attiva.
 233
 234 \subsection{Un esempio di connessione}
 235 \label{sec:TCPel_conn_dia}
 236
 237 Le operazioni del TCP nella creazione e conclusione di una connessione sono
 238 specificate attraverso il diagramma di transizione degli stati riportato in
 239 \nfig. TCP prevede l'esistenza di 11 diversi stati per un socket ed un insieme
 240 di regole per le transizioni da uno stato all'altro basate sullo stato
 241 corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
 242 che vengono riportati del comando \texttt{netstat} nel campo \textit{State}.
 243
 244 Una descrizione completa del funzionamento del protocollo va al di là degli
 245 obiettivi di questo libro; un approfondimento sugli aspetti principali si
 246 trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
 247 riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a descrivere
 248 brevemente un semplice esempio di connessione e le transizioni che avvengono
 249 nei due casi appena citati (creazione e terminazione della connessione).
 250
 251 In assenza di connessione lo stato del TCP è \textsl{CLOSED}; quando una
 252 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
 253 diventa \textsl{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
 254 emette un ACK e passa allo stato \textsl{ESTABLISHED}; questo è lo stato
 255 finale in cui avviene la gran parte del trasferimento dei dati.
 256
 257 Dal lato server in genere invece il passaggio che si opera con l'apertura
 258 passiva è quello di portare il socket dallo stato \textsl{CLOSED} allo
 259 stato \textsl{LISTEN} in cui vengono accettate le connessioni.
 260
 261 Dallo stato \textsl{ESTABLISHED} si può uscire in due modi; se un'applicazione
 262 chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
 263 attiva) la transizione è verso lo stato \textsl{FIN\_WAIT\_1}; se invece
 264 l'applicazione riceve un FIN nello stato \textsl{ESTABLISHED} (chiusura
 265 passiva) la transizione è verso lo stato \textsl{CLOSE\_WAIT}.
 266
 267 In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
 268 una un esempio di connessione, insieme ai vari stati che il protocollo viene
 269 ad assumere per i due lati, server e client.
 270
 271 \begin{figure}[htb]
 272   \centering
 273
 274   \caption{Schema dello scambio di pacchetti per un esempio di connessione}
 275   \label{fig:TPCel_conn_example}
 276 \end{figure}
 277
 278 La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
 279 valore tipico per IPv4 su ethernet) con linux, il server risponde con lo
 280 stesso valore (ma potrebbe essere anche un valore diverso).
 281
 282 Una volta che la connessione è stabilita il client scrive al server una
 283 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
 284 1460 bytes annunciati dal server), quest'ultimo riceve la richiesta e
 285 restituisce una risposta (che di nuovo supponiamo stare in un singolo
 286 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
 287 risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
 288 volte che che il server è sufficientemente veloce a costruire la risposta, in
 289 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
 290 risposta.
 291
 292 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
 293 secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo della
 294 connessione che esegue la chiusura attiva entra nello stato
 295 \textsl{TIME\_WAIT} su cui torneremo fra poco.
 296
 297 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
 298 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
 299 fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
 300 costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
 301 fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
 302 dettagli (come la verifica della ricezione dei pacchetti) dal livello del
 303 trasporto all'interno dell'applicazione.
 304
 305 Quello che è bene sempre tenere presente è allora quali sono le esigenze che
 306 si hanno in una applicazione di rete, perché non è detto che TCP sia la
 307 miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
 308 già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
 309 per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
 310 specifico le sue caratteristiche di velocità e compattezza nello scambio dei
 311 dati rispondono meglio alle esigenze che devono essere affrontate.
 312
 313 \subsection{Lo stato \texttt{TIME\_WAIT}}
 314 \label{sec:TCPel_time_wait}
 315
 316 Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
 317 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
 318 comune trovare nei newsgroup domande su come sia possibile evitare che
 319 un'applicazione resti in questo stato lasciando attiva una connessione ormai
 320 conclusa; la risposta è che non deve essere fatto, ed il motivo cercheremo di
 321 spiegarlo adesso.
 322
 323 Come si è visto nell'esempio precedente (vedi \curfig) \texttt{TIME\_WAIT} è
 324 lo stato finale in cui il capo di una connessione che esegue la chiusura
 325 attiva resta prima di passare alla chiusura definitiva della connessione. Il
 326 tempo in cui l'applicazione resta in questo stato deve essere due volte la MSL
 327 (\textit{Maximum Segment Lifetime}).
 328
 329 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
 330 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
 331 ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
 332 Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
 333 IP (per maggiori dettagli vedi \secref{sec:appA_xxx}), e viene decrementato ad
 334 ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
 335 Siccome il numero è ad 8 bit il numero massimo di ``salti'' è di 255, pertanto
 336 anche se il TTL (da \textit{time to live}) non è propriamente un limite sul
 337 tempo di vita, si stima che un pacchetto IP non possa restare nella rete per
 338 più di MSL secondi.
 339
 340 Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
 341 raccomanda 2 minuti, linux usa 30 secondi), questo comporta una durata dello
 342 stato \textsl{TIME\_WAIT} che a seconda delle implementazioni può variare fra
 343 1 a 4 minuti.
 344
 345 Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
 346 principali:
 347 \begin{itemize}
 348 \item implementare in maniera affidabile la terminazione della connessione
 349   in entrambe le direzioni.
 350 \item consentire l'eliminazione dei segmenti duplicati dalla rete.
 351 \end{itemize}
 352
 353 Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
 354 riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
 355 capisce il perché della scelta di un tempo pari al doppio della MSL come
 356 durata di questo stato.
 357
 358 Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
 359 che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
 360 attiva) vanga perso, chi esegue la chiusura passiva non ricevndo risposta
 361 rimanderà un ulteriore FIN, per questo motivo chi esegue la chiusura attiva
 362 deve mantenere lo stato della connessione per essere in grado di reinviare
 363 l'ACK e chiuderla correttamente. Se non fosse così la risposta sarebbe un RST
 364 (un altro tipo si segmento) che verrebbe interpretato come un errore.
 365
 366 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
 367 connessione allora deve essere in grado di affrontare la perdita di uno
 368 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
 369 motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
 370 dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale
 371 ritrasmissione in caso di perdita.
 372
 373
 374 Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
 375 gli scenari in cui accade che i pacchetti si possono perdere nella rete o
 376 restare intrappolati, per poi riemergere.
 377
 378 Il caso più comune in cui questo avviene è quello di anomalie
 379 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
 380 una connessione fra due router si interrompa. In questo caso i protocolli di
 381 instradamento dei pacchetti possono impiegare diverso temo (anche dell'ordine
 382 dei minuti) prima di trovare e stabilire un percorso alternativo per i
 383 pacchetti. Nel frattempo possono accadere casi in cui un router manda i
 384 pacchetti verso un'altro e quest'ultimo li rispedisce indietro, o li manda ad
 385 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
 386 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
 387
 388 Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
 389 non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
 390 stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
 391 destinazione. Ma se dopo un po' di tempo (che non supera il limite dell'MSL)
 392 l'anomalia viene a cessare il circolo di instadamento viene spezzato i
 393 pacchetti intrappolati potranno essere inviati alla destinazione finale, con
 394 la conseguenza di avere dei pacchetti duplicati; questo è un caso che il TCP
 395 deve essere in grado di gestire.
 396
 397 Allora per capire la seconda ragione per l'esistenza dello stato
 398 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
 399 connessione fra l'IP 195.110.112.236 porta 1550 e l'IP 192.84.145.100 porta
 400 22, che questa venga chiusa e che poco dopo si ristabilisca la stessa
 401 connessione fra gli stessi IP sulle stesse porte (quella che viene detta,
 402 essendo gli stessi porte e numeri IP, una nuova \textsl{incarnazione} della
 403 connessione precedente); in questo caso ci si potrebbe trovare con dei
 404 pacchetti duplicati relativi alla precedente connessione che riappaiono nella
 405 nuova.
 406
 407 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
 408 creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
 409 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
 410 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
 411 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
 412 sicuri che lo stesso avvenga le risposte nella direzione opposta.
 413
 414 In questo modo il TCP si assicura che quando una viene creata una nuova
 415 connessione tutti gli eventuali segmenti residui di una precedente connessione
 416 che possono causare disturbi sono stati eliminati dalla rete.
 417
 418
 419 \subsection{I numeri di porta}
 420 \label{sec:TCPel_port_num}
 421
 422 In un ambiente multitasking in un dato momento più processi possono dover
 423 usare sia UDP che TCP, e ci devono poter essere più connessioni in
 424 contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
 425 protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
 426 vedere in \secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle strutture
 427 degli indirizzi del socket.
 428
 429 Quando un client contatta un server deve poter identificare con quale dei vari
 430 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
 431 di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
 432 identificano una serie di servizi noti (ad esempio la porta 22 identifica il
 433 servizio \texttt{ssh}) effettuati da appositi server che rispondono alle
 434 connessioni verso tali porte.
 435
 436 D'altra parte un client non ha necessità di usare un numero di porta
 437 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
 438   effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
 439 nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
 440 creazione della connessione. Queste sono dette effimere in quanto vengono
 441 usate solo per la durata della connessione, e l'unico requisito che deve
 442 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
 443
 444 La lista delle porte conosciute è definita dall'RFC1700 che contiene l'elenco
 445 delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
 446 ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
 447 \texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
 448 file \texttt{/etc/services} contiene un analogo elenco, con la corrispondenza
 449 fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
 450 in tre intervalli:
 451
 452 \begin{enumerate}
 453 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
 454   controllate e assegnate dalla IANA. Se è possibile la stessa porta è
 455   assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
 456   è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal
 457   TCP).
 458
 459 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
 460   sono controllate dalla IANA, che però registra ed elenca chi usa queste
 461   porte come servizio agli utenti. Come per le precedenti si assegna una porta
 462   ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
 463   solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
 464   anche se il protocollo è implementato solo tramite TCP.
 465
 466 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
 467   65535. La IANA non dice nulla riguardo a queste porte che pertanto
 468   sono i candidati naturali ad essere usate come porte effimere.
 469 \end{enumerate}
 470
 471 In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
 472 scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
 473 quelle di BSD, Solaris e linux. Nel caso di linux poi la scelta fra i due
 474 intervali possibili viene fatta dinamicamente a seconda della memoria a
 475 disposizione del kernel per gestire le rative tabelle.
 476
 477 \begin{figure}[!htb]
 478   \centering
 479
 480   \caption{Allocazione dei numeri di porta}
 481   \label{fig:TCPel_port_alloc}
 482 \end{figure}
 483
 484 I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
 485 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
 486 porte conosciute). La loro caratteristica è che possono essere assegnate a un
 487 socket solo da un processo con i privilegi di root, per far si che solo
 488 l'amministratore possa allocare queste porte per far partire relativi servizi.
 489
 490 Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
 491 \texttt{rlogin}) che richiedono una connessione su una porta riservata anche
 492 dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
 493 funzione \texttt{rresvport} assegnando al socket una porta libera
 494 nell'intervallo fra 512 e 1023.
 495
 496 Data una connessione TCP si suole chiamare \textit{socket pair} la
 497 combinazione dei quattro numeri che definiscono i due capi della connessione e
 498 cioè l'indirizzo IP locale e la porta TCP locale, e l'indirizzo IP remoto e la
 499 porta TCP remota; questa combinazione, che scriveremo usando una notazione del
 500 tipo $(195.110.112.152:22, 192.84.146.100:20100)$, identifica univocamente una
 501 connessione su internet. Questo concetto viene di solito esteso anche a UDP,
 502 benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
 503 programma \texttt{netstat} permette di visualizzare queste informazioni nei
 504 campi \textit{Local Address} e \textit{Foreing Address}.
 505
 506
 507 \subsection{Le porte ed il modello client/server}
 508 \label{sec:TCPel_port_cliserv}
 509
 510 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
 511 che fare con un'applicazione client/server (come quella che scriveremo in
 512 \secref{sec:TCPel_echo_example}) esaminaremo cosa accade con le connessioni nel
 513 caso di un server TCP che deve gestire connessioni multiple.
 514
 515 Se esguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
 516 indirizzo 195.110.112.152) potremo avere un risultato del tipo:
 517 \begin{verbatim}
 518 Active Internet connections (servers and established)
 519 Proto Recv-Q Send-Q Local Address           Foreign Address         State
 520 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
 521 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
 522 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
 523 \end{verbatim}
 524 essendo presenti e attivi un server ssh, un server di posta e un DNS per il
 525 caching locale.
 526
 527 Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
 528 mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
 529 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
 530 associati alle interfaccie locali; la notazione 0.0.0.0 usata da netstat è
 531 equivalente all'asterisco utilizzato per il numero di porta ed indica il
 532 valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
 533 \texttt{arpa/inet.h}.
 534
 535 Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
 536 specificati; in questo caso la \textit{socket pair} associata al socket può
 537 essere indicata come $(*:22, *.*)$, usando l'asterisco anche per gli indirizzi
 538 come carattere di \textit{wildchard}.
 539
 540 In genere avendo le macchine associato un solo IP ci si può chiedere che senso
 541 abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
 542 anche macchine che hanno più di un indirizzo IP (il cosiddetto
 543 \textit{miltihoming}) in questo modo si possono accettare connessioni
 544 indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
 545 con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
 546 solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
 547 caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
 548 loopback.
 549
 550 Una volta che ci si vorrà collegare a questa macchina da un'altra posta
 551 all'indirizzo 192.84.146.100 si potrà lanciare un client \texttt{ssh} per
 552 creare una connessione verso la precedente, e il kernel associerà al suddetto
 553 una porta effimera che per esempio potrà essere la 21100, la connessione
 554 allora sarà espressa dalla socket pair $(192.84.146.100:21100,
 555 195.110.112.152.22)$.
 556
 557 Alla ricezione della richiesta dal client il server creerà un processo figlio
 558 per gestire la connessione, se a questo punto eseguiamo nuovamente il
 559 programma netstat otterremo come risultato:
 560 \begin{verbatim}
 561 Active Internet connections (servers and established)
 562 Proto Recv-Q Send-Q Local Address           Foreign Address         State
 563 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
 564 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
 565 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
 566 tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
 567 \end{verbatim}
 568
 569 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
 570 c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
 571 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
 572 il processo figlio gestisce la connessione mentre il padre resta in ascolto
 573 sul socket originale.
 574
 575 Se a questo punto lanciamo un'altra volta il client ssh per una seconda
 576 conessione quello che otterremo usando netstat sarà qualcosa del genere:
 577 \begin{verbatim}
 578 Active Internet connections (servers and established)
 579 Proto Recv-Q Send-Q Local Address           Foreign Address         State
 580 tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
 581 tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
 582 tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
 583 tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
 584 tcp        0      0 195.110.112.152:22      192.84.146.100:21101    ESTABLISHED
 585 \end{verbatim}
 586 cioè il client effettuerà la connessione usando un'altra porta effimera, con
 587 questa sarà aperta la connessione, ed il server creerà un'altro processo
 588 figlio sarà creato per gestirla.
 589
 590 Tutto ciò mostra come TCP, per poter gestire le connessioni con un server
 591 concorrente, non può suddividere i pacchetti solo sulla base della porta di
 592 destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
 593 compresa la porta dell'indirizzo remoto.  E se andassimo a vedere quali sono i
 594 processi a cui fanno riferimento i vari socket vedremmo che i pacchetti che
 595 arrivano dalla porta remota 21100 vanno al primo figlio e quelli che arrivano
 596 alla porta 21101 al secondo.
 597
 598
 599 \section{Le funzioni dei socket TCP}
 600 \label{sec:TCPel_functions}
 601
 602 In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
 603 l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
 604 \secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}) con l'eccezione
 605 della funzione \texttt{socket} che è già stata esaminata in dettaglio in
 606 \secref{sec:sock_socket}.
 607
 608 In \nfig\ abbiamo un tipico schema di funzionamento di un'applicazione
 609 client-server che usa i socket TCP: prima il server viene avviato ed in
 610 seguito il client si connette, in questo caso, a differenza di quanto accadeva
 611 con gli esempi elementari del Cap.~\capref{cha:network} si assume che sia il
 612 client ad effettuare delle richieste a cui il server risponde, il client
 613 notifica poi di avere concluso inviando un end-of-file a cui il server
 614 risponderà anche lui chiudendo la connessione per aspettarne una nuova.
 615
 616 \begin{figure}[!htb]
 617   \centering
 618
 619   \caption{Struttura delle funzioni dei socket per una semplice applicazione
 620     client/server su TCP.}
 621   \label{fig:TCPel_cliserv_func}
 622 \end{figure}
 623
 624 Useremo questo schema per l'esempio di implementazione del servizio
 625 \texttt{echo} che illustreremo in \secref{sec:TCPel_echo_example}.
 626
 627
 628 \subsection{La funzione \texttt{bind}}
 629 \label{sec:TCPel_func_bind}
 630
 631
 632 La funzione \texttt{bind} assegna un indirizzo locale ad un socket, è usata
 633 cioè per specificare la prima parte dalla socket pair. Viene usata sul lato
 634 server per specificare la porta (e gli eventuali indirizzi locali) su cui poi
 635 ci si porrà in ascolto.
 636
 637 Il prototipo della funzione, definito in \texttt{sys/socket.h}, è il seguente:
 638
 639 \begin{itemize}
 640 \item \texttt{int bind(int sockfd, const struct sockaddr *serv\_addr,
 641     socklen\_t addrlen) }
 642
 643   Il primo argomento è un file descriptor ottenuto da una precedente chiamata
 644   a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
 645   l'indirizzo (locale) del socket e la dimensione della struttura che lo
 646   contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
 647
 648   La funzione restituisce zero in caso di successo e -1 per un errore, in caso
 649   di errore. La variabile \texttt{errno} viene settata secondo i seguenti
 650   codici di errore:
 651   \begin{itemize}
 652   \item \texttt{EBADF} Il file descriptor non è valido.
 653   \item \texttt{EINVAL} Il socket ha già un indirizzo assegnato.
 654   \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
 655   \item \texttt{EACCESS} Si è cercato di usare un indirizzo riservato senza
 656     essere root.
 657   \end{itemize}
 658
 659 \end{itemize}
 660
 661 Con il TCP la chiamata \texttt{bind} permette di specificare l'indirizzo, la
 662 porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
 663 nota che assegnano all'avvio, se questo non viene fatto è il kernel a
 664 scegliere una porta effimera quando vengono eseguite la funzioni
 665 \texttt{connect} o \texttt{listen}, ma se questo è normale per il client non
 666 lo è per il server\footnote{un'eccezione a tutto ciò i server che usano RPC.
 667   In questo caso viene fatta assegnare dal kernel una porta effimera che poi
 668   viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
 669   demone che deve essere contattato dai client per ottenere la porta effimera
 670   su cui si trova il server} che in genere viene identificato dalla porta su
 671 cui risponde.
 672
 673 Con \texttt{bind} si può assegnare un IP specifico ad un socket, purché questo
 674 appartenga ad una interfaccia della macchina.  Per un client TCP questo
 675 diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati sul
 676 socket, mentre per un server TCP questo restringerà l'accesso al socket solo
 677 alle connessioni che arrivano verso tale indirizzo.
 678
 679 Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
 680 kernel sceglie l'indirizzo di orgine quando viene effettuata la connessione
 681 sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
 682 dalle regole di instradamento usate per raggiungere il server).
 683 Se un server non specifica il suo indirizzo locale il kernel userà come
 684 indirizzo di origine l'indirizzo di destinazione specificato dal SYN del
 685 client.
 686
 687 Per specificare un indirizzo generico con IPv4 si usa il valore
 688 \texttt{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
 689 è pari a zero, nell'esempio \figref{fig:net_serv_sample} si è usata
 690 un'assegnazione immediata del tipo:
 691 \begin{verbatim}
 692    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
 693 \end{verbatim}
 694
 695 Si noti che si è usato \texttt{htonl} per assegnare il valore
 696 \texttt{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
 697 inutile; ma dato che tutte le constanti \texttt{INADDR\_} sono definite
 698 secondo l'ordinamento della macchina è buona norma usare sempre la funzione
 699 \texttt{htonl}.
 700
 701 L'esempio precedete funziona con IPv4 dato che l'indirizzo è rappresentabile
 702 anche con un intero a 32 bit; non si può usare lo stesso metodo con IPv6,
 703 in cui l'indirizzo è specificato come struttura, perché il linguaggio C non
 704 consente l'uso di una struttura costante come operando a destra in una
 705 assegnazione.  Per questo nell'header \texttt{netinet/in.h} è definita una
 706 variabile \texttt{in6addr\_any} (dichiarata come \texttt{extern}, ed
 707 inizializzata dal sistema al valore \texttt{IN6ADRR\_ANY\_INIT}) che permette
 708 di effettuare una assegnazione del tipo:
 709 \begin{verbatim}
 710    serv_add.sin6_addr = in6addr_any;   /* connect from anywhere */
 711 \end{verbatim}
 712
 713
 714 \subsection{La funzione \texttt{connect}}
 715 \label{sec:TCPel_func_connect}
 716
 717 La funzione \texttt{connect} è usata da un client TCP per stabilire la
 718 connessione con un server TCP, il prototipo della funzione, definito in
 719 \texttt{sys/socket.h}, è il seguente:
 720
 721 \begin{itemize}
 722 \item \texttt{int connect(int sockfd, const struct sockaddr *serv\_addr,
 723     socklen\_t addrlen) }
 724
 725   Il primo argomento è un file descriptor ottenuto da una precedente chiamata
 726   a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
 727   l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
 728   socket, già descritta in \secref{sec:sock_sockaddr}.
 729
 730   La funzione restituisce zero in caso di successo e -1 per un errore, in caso
 731   di errore. La variabile \texttt{errno} viene settata secondo i seguenti
 732   codici di errore:
 733   \begin{itemize}
 734   \item \texttt{EBADF} Il file descriptor non è valido.
 735   \item \texttt{EFAULT} L'indirizzo della struttura di indirizzi è al di fuori
 736     dello spazio di indirizzi dell'utente.
 737   \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
 738   \item \texttt{EISCONN} Il socket è già connesso.
 739   \item \texttt{ECONNREFUSED} Non c'è nessuno in ascolto sull'indirizzo remoto.
 740   \item \texttt{ETIMEDOUT} Si è avuto timeout durante il tentativo di
 741     connessione.
 742   \item \texttt{ENETUNREACH} La rete non è raggiungibile.
 743   \item \texttt{EADDRINUSE} L'indirizzo locale è in uso.
 744   \item \texttt{EINPROGRESS} Il socket è non bloccante e la connessione non
 745     può essere conclusa immediatamente.
 746   \item \texttt{EALREADY} Il socket è non bloccante e un tentativo precedente
 747     di connessione non si è ancora concluso.
 748   \item \texttt{EAGAIN} Non ci sono più porte locali libere.
 749   \item \texttt{EAFNOSUPPORT} L'indirizzo non ha una famiglia di indirizzi
 750     corretta nel relativo campo.
 751   \item \texttt{EACCESS, EPERM} Si è tentato di eseguire una connessione ad un
 752     indirizzo broacast senza che il socket fosse stato abilitato per il
 753     broadcast.
 754   \end{itemize}
 755 \end{itemize}
 756
 757 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
 758 numero di porta del server a cui ci si vuole connettere, come mostrato
 759 nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
 760 \secref{sec:sock_addr_func}.
 761
 762 Nel caso di socket TCP la funzione \texttt{connect} avvia il three way
 763 handshake, e ritorna solo quando la connessione è stabilita o si è verificato
 764 un errore. Le possibili cause di errore sono molteplici (ed i relativi codici
 765 riportati sopra), quelle che però dipendono dalla situazione della rete e non
 766 da errori o problemi nella chiamata della funzione sono le seguenti:
 767
 768 \begin{enumerate}
 769 \item Il client non riceve risposta al SYN: l'errore restituito è
 770   \texttt{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
 771   di \texttt{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
 772   dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
 773   invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
 774   di volte che può essere stabilito dall'utente sia con una opportuna
 775   \texttt{sysctl} che attraverso il filesystem \texttt{/proc} scrivendo il
 776   valore voluto in \texttt{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore di
 777   default per la ripetizione dell'invio è di 5 volte, che comporta un timeout
 778   dopo circa 180 secondi.
 779 %
 780 % Le informazioni su tutte le opzioni settabili via /proc stanno in
 781 % linux/Documentation/networking/ip-sysctl.txt
 782 %
 783 \item Il client riceve come risposta al SYN un RST significa che non c'è
 784   nessun programma in ascolto per la connessione sulla porta specificata (il
 785   che vuol dire probablmente che o si è sbagliato il numero della porta o che
 786   non è stato avviato il server), questo è un errore fatale e la funzione
 787   ritorna non appena il RST viene ricevuto riportando un errore
 788   \texttt{ECONNREFUSED}.
 789
 790   Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
 791   dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
 792   quando arriva un SYN per una porta che non ha nessun server in ascolto,
 793   quando il TCP abortisce una connessione in corso, quandi TCP riceve un
 794   segmento per una connessione che non esiste.
 795
 796 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
 797   destinazione non raggiungibile. In questo caso dato che il messaggio può
 798   essere dovuto ad una condizione transitoria si ripete l'emmissione dei SYN
 799   come nel caso precedente, fino al timeout, e solo allora si restituisce il
 800   codice di errore dovuto al messaggio ICMP, che da luogo ad un
 801   \texttt{ENETUNREACH}.
 802
 803 \end{enumerate}
 804
 805 Se si fa riferimento al diagramma degli stati del TCP riportato in
 806 \figref{fig:appB:tcp_state_diag} la funzione \texttt{connect} porta un socket
 807 dallo stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket
 808 appena creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento del
 809 ACK, nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il
 810 socket non è più utilizzabile e deve essere chiuso.
 811
 812 Si noti infine che con la funzione \texttt{connect} si è specificato solo
 813 indirizzo e porta del server, quindi solo una metà della socket pair; essendo
 814 questa funzione usata nei client l'altra metà contentente indirizzo e porta
 815 locale viene lasciata all'assegnazione automatica del kernel, e non è
 816 necessario effettuare una \texttt{bind}.
 817
 818
 819 \subsection{La funzione \texttt{listen}}
 820 \label{sec:TCPel_func_listen}
 821
 822 La funzione \texttt{listen} è usata per usare un socket in modalità passiva,
 823 cioè, come dice il nome, per metterlo in ascolto di eventuali connessioni; in
 824 sostanza l'effetto della funzione è di portare il socket dallo stato
 825 \texttt{CLOSED} a quello \texttt{LISTEN}.
 826
 827 \begin{prototype}{int listen(int sockfd, int backlog)}
 828   \begin{errlist}
 829   \item \texttt{EBADF} L'argomento \texttt{sockfd} non è un file descriptor
 830     valido.
 831   \item \texttt{ENOTSOCK} L'argomento \texttt{sockfd} non è un socket.
 832   \item \texttt{EOPNOTSUPP} The socket is not of a type that supports the lis
 833     ten operation.
 834   \end{errlist}
 835 \end{prototype}
 836
 837
 838
 839 \subsection{La funzione \texttt{accept}}
 840 \label{sec:TCPel_func_accept}
 841
 842
 843 \section{Una semplice implementazione del servizio \texttt{echo} su TCP}
 844 \label{sec:TCPel_echo_example}