elemtcp.tex

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