Revisione di parecchia roba sulle reti, rimessi insieme gli esempi ed una
authorSimone Piccardi <piccardi@gnulinux.it>
Mon, 21 Apr 2003 22:32:14 +0000 (22:32 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Mon, 21 Apr 2003 22:32:14 +0000 (22:32 +0000)
nuova figura.

elemtcp.tex
img/port_alloc.dia
img/tcp_listen_backlog.dia [new file with mode: 0644]
process.tex
simpltcp.tex
socket.tex

index ba1760a..45584ea 100644 (file)
 \label{cha:elem_TCP_sock}
 
 In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP,
-tratteremo qui dunque le varie funzioni che si sono usate nei due esempi
-elementari forniti nel capitolo precedente (vedi \secref{sec:net_cli_sample} e
-\secref{sec:net_serv_sample}), previa una descrizione delle principali
-caratteristiche del funzionamento di una connessione TCP.
+iniziando con una descrizione delle principali caratteristiche del
+funzionamento di una connessione TCP.  Tratteremo poi le varie funzioni che
+servono alla creazione di una connessione fra un server elementare ed il suo
+client, fornendo poi alcuni esempi di applicazione elementare.
+
 
 
 \section{Il funzionamento di una connessione TCP}
-\label{sec:TCPel_connession}
+\label{sec:TCP_connession}
 
-Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
-utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del
-funzionamento del protocollo poiché questa conoscenza è essenziale per
-comprendere il comportamento di dette funzioni per questi socket, ed il
-relativo modello di programmazione.
+Prima di entrare nei dettagli delles singole funzioni usate nelle applicazioni
+che utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del
+funzionamento del protocollo, poiché questa conoscenza è essenziale per
+comprendere il comportamento di dette funzioni per questo tipo di socket, ed
+il relativo modello di programmazione.
 
-Il protocollo TCP serve a creare degli \textit{stream socket}, cioè un canale
-di comunicazione che stabilisce una connessione fra due stazioni, in modo che
-queste possano scambiarsi i dati. In questo capitolo ci concentreremo sulle
-modalità con le quali il protocollo dà inizio e conclude una connessione e
-faremo inoltre un breve accenno al significato di alcuni dei vari stati che
-questa viene ad assumere durante la sua vita.
+Si ricordi che il protocollo TCP serve a creare degli \textit{stream socket},
+cioè una forma di canale di comunicazione che stabilisce una connessione
+stabile fra due stazioni, in modo che queste possano scambiarsi dei dati. In
+questa sezione ci concentreremo sulle modalità con le quali il protocollo dà
+inizio e conclude una connessione e faremo inoltre un breve accenno al
+significato di alcuni dei vari \textsl{stati} ad essa associati.
 
 \subsection{La creazione della connessione: il \textit{three way handshake}}
-\label{sec:TCPel_conn_cre}
+\label{sec:TCP_conn_cre}
 
 Il processo che porta a creare una connessione TCP è chiamato \textit{three
-  way handshake}; la successione tipica degli eventi (la stessa che si
-verifica utilizzando il codice dei due precedenti esempi elementari
-\figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
-creazione di una connessione è la seguente:
+  way handshake}; la successione tipica degli eventi (e dei
+\textsl{segmenti}\footnote{Si ricordi che il segmento è l'unità elementare di
+  dati trasmessa dal protocollo TCP al livello successivo; tutti i segmenti
+  hanno un header che contiene le informazioni che servono allo \textit{stack
+    TCP} (così viene di solito chiamata la parte del kernel che implementa il
+  protocollo) per realizzare la comunicazione, fra questi dati ci sono una
+  serie di flag usati per gestire la connessione, come SYN, ACK, URG, FIN,
+  alcuni di essi, come SYN (che sta per \textit{syncronize}) corrispondono a
+  funzioni particolari del protocollo e danno il nome al segmento, (per
+  maggiori dettagli vedere \capref{cha:tcp_protocol}).}  di dati che vengono
+scambiati) che porta alla creazione di una connessione è la seguente:
  
 \begin{enumerate}
 \item Il server deve essere preparato per accettare le connessioni in arrivo;
   il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
-  \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
+  \textit{passive open}). Questo viene fatto chiamando la sequenza di funzioni
   \func{socket}, \func{bind} e \func{listen}. Completata l'apertura passiva il
   server chiama la funzione \func{accept} e il processo si blocca in attesa di
   connessioni.
@@ -55,18 +63,9 @@ creazione di una connessione 
   \func{connect}, attraverso un procedimento che viene chiamato
   \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
   \func{connect} blocca il processo e causa l'invio da parte del client di un
-  segmento SYN,\footnote{Si ricordi che il segmento è l'unità elementare di
-    dati trasmessa dal protocollo TCP al livello successivo; tutti i segmenti
-    hanno un header che contiene le informazioni che servono allo
-    \textit{stack TCP} (così viene di solito chiamata la parte del kernel che
-    implementa il protocollo) per realizzare la comunicazione, fra questi dati
-    ci sono una serie di flag usati per gestire la connessione, come SYN, ACK,
-    URG, FIN, alcuni di essi, come SYN (che sta per \textit{syncronize})
-    corrispondono a funzioni particolari del protocollo e danno il nome al
-    segmento, (per maggiori dettagli vedere \capref{cha:tcp_protocol}).} in
-  sostanza viene inviato al server un pacchetto IP che contiene solo gli
-  header IP e TCP (con il numero di sequenza iniziale e il flag SYN) e le
-  opzioni di TCP.
+  segmento SYN, in sostanza viene inviato al server un pacchetto IP che
+  contiene solo gli header IP e TCP (con il numero di sequenza iniziale e il
+  flag SYN) e le opzioni di TCP.
   
 \item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del
   client, inoltre anche il server deve inviare il suo SYN al client (e
@@ -81,7 +80,7 @@ creazione di una connessione 
 \end{enumerate} 
 
 Il procedimento viene chiamato \textit{three way handshake} dato che per
-realizzarlo devono essere scambiati tre segmenti.  In \figref{fig:TCPel_TWH}
+realizzarlo devono essere scambiati tre segmenti.  In \figref{fig:TCP_TWH}
 si è rappresentata graficamente la sequenza di scambio dei segmenti che
 stabilisce la connessione.
 
@@ -97,12 +96,12 @@ stabilisce la connessione.
 \begin{figure}[htb]
   \centering
   \includegraphics[width=10cm]{img/three_way_handshake}  
-  \caption{Il \textit{three way handshake} del TCP}
-  \label{fig:TCPel_TWH}
+  \caption{Il \textit{three way handshake} del TCP.}
+  \label{fig:TCP_TWH}
 \end{figure}
 
 Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
-riportati in \figref{fig:TCPel_TWH}); per gestire una connessione affidabile
+riportati in \figref{fig:TCP_TWH}); per gestire una connessione affidabile
 infatti il protocollo TCP prevede nell'header la presenza di un numero a 32
 bit (chiamato appunto \textit{sequence number}) che identifica a quale byte
 nella sequenza del flusso corrisponde il primo byte della sezione dati
@@ -117,10 +116,10 @@ il flag ACK e restituendo nell'apposito campo dell'header un
 aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto
 SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge
 è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
-varrà anche (vedi \figref{fig:TCPel_close}) per l'acknowledgement di un FIN.
+varrà anche (vedi \figref{fig:TCP_close}) per l'acknowledgement di un FIN.
 
 \subsection{Le opzioni TCP.}
-\label{sec:TCPel_TCP_opt}
+\label{sec:TCP_TCP_opt}
 
 Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
 (le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
@@ -134,25 +133,25 @@ regolare la connessione. Normalmente vengono usate le seguenti opzioni:
   connessione corrente. È possibile leggere e scrivere questo valore
   attraverso l'opzione del socket \const{TCP\_MAXSEG}.
   
-\item \textit{window scale option}come spiegato in \capref{cha:tcp_protocol}
+\item \textit{window scale option}, %come spiegato in \capref{cha:tcp_protocol}
   il protocollo TCP implementa il controllo di flusso attraverso una
   \textsl{finestra annunciata} (\textit{advertized window}) con la quale
   ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
   memoria per i dati. Questo è un numero a 16 bit dell'header, che così può
-  indicare un massimo di 65535 byte (anche se Linux usa come massimo 32767 per
-  evitare problemi con alcuni stack bacati che usano l'aritmetica con segno
-  per implementare lo stack TCP); ma alcuni tipi di connessione come quelle ad
-  alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi ritardi nel
-  cammino dei pacchetti (come i satelliti) richiedono una finestra più grande
-  per poter ottenere il massimo dalla trasmissione, per questo esiste questa
-  opzione che indica un fattore di scala da applicare al valore della finestra
-  annunciata\footnote{essendo una nuova opzione per garantire la compatibilità
-    con delle vecchie implementazioni del protocollo la procedura che la
-    attiva prevede come negoziazione che l'altro capo della connessione
-    riconosca esplicitamente l'opzione inserendola anche lui nel suo SYN di
-    risposta dell'apertura della connessione.} per la connessione corrente
-  (espresso come numero di bit cui spostare a sinistra il valore della
-  finestra annunciata inserito nel pacchetto).
+  indicare un massimo di 65535 byte;\footnote{ Linux usa come massimo 32767
+    per evitare problemi con alcune implementazioni che usano l'aritmetica con
+    segno per implementare lo stack TCP.} ma alcuni tipi di connessione come
+  quelle ad alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi
+  ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
+  più grande per poter ottenere il massimo dalla trasmissione, per questo
+  esiste questa opzione che indica un fattore di scala da applicare al valore
+  della finestra annunciata\footnote{essendo una nuova opzione per garantire
+    la compatibilità con delle vecchie implementazioni del protocollo la
+    procedura che la attiva prevede come negoziazione che l'altro capo della
+    connessione riconosca esplicitamente l'opzione inserendola anche lui nel
+    suo SYN di risposta dell'apertura della connessione.} per la connessione
+  corrente (espresso come numero di bit cui spostare a sinistra il valore
+  della finestra annunciata inserito nel pacchetto).
 
 \item \textit{timestamp option}, è anche questa una nuova opzione necessaria
   per le connessioni ad alta velocità per evitare possibili corruzioni di dati
@@ -168,12 +167,12 @@ che viene dato alle connessioni caratterizzate da alta velocit
 elevati. In ogni caso Linux supporta pienamente entrambe le opzioni.
 
 \subsection{La terminazione della connessione}
-\label{sec:TCPel_conn_term}
+\label{sec:TCP_conn_term}
 
 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
 procedura di chiusura ne richiede quattro; ancora una volta si può fare
-riferimento al codice degli esempi \figref{fig:net_cli_code} e
-\figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
+riferimento al codice degli esempi \figref{fig:TCP_cli_code} e
+\figref{fig:TCP_serv_code}, in questo caso la successione degli eventi è la
 seguente:
 
 \begin{enumerate}
@@ -203,14 +202,14 @@ normalmente i segmenti scambiati sono quattro.  Questo non 
 giacché in alcune situazioni il FIN del passo 1) è inviato insieme a dei dati.
 Inoltre è possibile che i segmenti inviati nei passi 2 e 3 dal capo che
 effettua la chiusura passiva, siano accorpati in un singolo segmento. In
-\figref{fig:TCPel_close} si è rappresentato graficamente lo sequenza di
-scambio dei segmenti che stabilisce la connessione.
+\figref{fig:TCP_close} si è rappresentato graficamente lo sequenza di
+scambio dei segmenti che conclude la connessione.
 
 \begin{figure}[htb]
   \centering  
   \includegraphics[width=10cm]{img/tcp_close}  
-  \caption{La chiusura di una connessione TCP}
-  \label{fig:TCPel_close}
+  \caption{La chiusura di una connessione TCP.}
+  \label{fig:TCP_close}
 \end{figure}
 
 Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
@@ -223,40 +222,42 @@ Nella sequenza indicata i dati verrebbero persi, dato che si 
 socket dal lato che esegue la chiusura attiva; esistono tuttavia situazioni in
 cui si vuole poter sfruttare questa possibilità, usando una procedura che è
 chiamata \textit{half-close}; torneremo su questo aspetto e su come
-utilizzarlo più avanti, quando parleremo della funzione \func{shutdown}.
+utilizzarlo in \secref{xxx_shutdown}, quando parleremo della funzione
+\func{shutdown}.
 
 La emissione del FIN avviene quando il socket viene chiuso, questo però non
-avviene solo per la chiamata della funzione \func{close} (come in
-\figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
-in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
-viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
+avviene solo per la chiamata della funzione \func{close} (come faremo in
+\figref{fig:TCP_serv_code}), ma anche alla terminazione di un processo (come
+vedremo in \figref{fig:TCP_cli_code}). Questo vuol dire ad esempio che se un
+processo viene terminato da un segnale tutte le connessioni aperte verranno
+chiuse.
 
-Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
-più avanti in \secref{sec:TCPsimp_echo}) sia stato il client ad eseguire la
-chiusura attiva, nella realtà questa può essere eseguita da uno qualunque dei
-due capi della comunicazione (come in fatto in precedenza nell'esempio di
-\figref{fig:net_serv_code}), e anche se il caso più comune resta quello del
-client, ci sono alcuni servizi, il principale dei quali è l'HTTP, per i
-quali è il server ad effettuare la chiusura attiva.
+Infine occorre sottolineare che, benché nella figura (e nell'esempio che
+vedremo più avanti in \secref{sec:TCPsimp_echo}) sia stato il client ad
+eseguire la chiusura attiva, nella realtà questa può essere eseguita da uno
+qualunque dei due capi della comunicazione (come nell'esempio di
+\figref{fig:TCP_serv_code}), e anche se il caso più comune resta quello del
+client, ci sono alcuni servizi, il principale dei quali è l'HTTP, per i quali
+è il server ad effettuare la chiusura attiva.
 
 
 \subsection{Un esempio di connessione}
-\label{sec:TCPel_conn_dia}
+\label{sec:TCP_conn_dia}
 
 Le operazioni del TCP nella creazione e conclusione di una connessione sono
 specificate attraverso il diagramma di transizione degli stati riportato in
-\figref{fig:TPCel_conn_example}. TCP prevede l'esistenza di 11 diversi stati
+\figref{fig:TCP_conn_example}. TCP prevede l'esistenza di 11 diversi stati
 per un socket ed un insieme di regole per le transizioni da uno stato
 all'altro basate sullo stato corrente e sul tipo di segmento ricevuto; i nomi
 degli stati sono gli stessi che vengono riportati del comando \cmd{netstat}
 nel campo \textit{State}.
 
-Una descrizione completa del funzionamento del protocollo va al di là degli
-obiettivi di questo libro; un approfondimento sugli aspetti principali si
-trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il
-miglior riferimento resta \cite{TCPIll1}; qui ci limiteremo a descrivere
-brevemente un semplice esempio di connessione e le transizioni che avvengono
-nei due casi appena citati (creazione e terminazione della connessione).
+Non possiamo affrontare una descrizione completa del funzionamento del
+protocollo; un approfondimento sugli aspetti principali si trova in
+\capref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
+riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un
+semplice esempio di connessione e le transizioni che avvengono nei due casi
+appena citati (creazione e terminazione della connessione).
 
 In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
 applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
@@ -269,40 +270,41 @@ passiva 
 stato \texttt{LISTEN} in cui vengono accettate le connessioni.
 
 Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
-chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
-attiva) la transizione è verso lo stato \texttt{FIN\_WAIT\_1}; se invece
-l'applicazione riceve un FIN nello stato \texttt{ESTABLISHED} (chiusura
-passiva) la transizione è verso lo stato \texttt{CLOSE\_WAIT}.
+chiama la funzione \texttt{close} prima di aver ricevuto un
+\textit{end-of-file} (chiusura attiva) la transizione è verso lo stato
+\texttt{FIN\_WAIT\_1}; se invece l'applicazione riceve un FIN nello stato
+\texttt{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato
+\texttt{CLOSE\_WAIT}.
 
-In \figref{fig:TPCel_conn_example} è riportato lo schema dello scambio dei
+In \figref{fig:TCP_conn_example} è riportato lo schema dello scambio dei
 pacchetti che avviene per una un esempio di connessione, insieme ai vari stati
 che il protocollo viene ad assumere per i due lati, server e client.
 
 \begin{figure}[htb]
   \centering
   \includegraphics[width=9cm]{img/tcp_connection}  
-  \caption{Schema dello scambio di pacchetti per un esempio di connessione}
-  \label{fig:TPCel_conn_example}
+  \caption{Schema dello scambio di pacchetti per un esempio di connessione.}
+  \label{fig:TCP_conn_example}
 \end{figure}
 
-La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
-valore tipico per IPv4 su Ethernet) con Linux, il server risponde con lo
-stesso valore (ma potrebbe essere anche un valore diverso).
+La connessione viene iniziata dal client che annuncia un MSS di 1460un
+valore tipico con Linux per IPv4 su Ethernet, il server risponde con lo stesso
+valore (ma potrebbe essere anche un valore diverso).
 
 Una volta che la connessione è stabilita il client scrive al server una
 richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
 1460 byte annunciati dal server), quest'ultimo riceve la richiesta e
 restituisce una risposta (che di nuovo supponiamo stare in un singolo
 segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
-risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
-volte che che il server è sufficientemente veloce a costruire la risposta, in
+risposta: questo viene chiamato \textit{piggybacking} ed avviene tutte le
+volte che che il server è sufficientemente veloce a costruire la risposta; in
 caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
 risposta.
 
 Infine si ha lo scambio dei quattro segmenti che terminano la connessione
-secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo
-della connessione che esegue la chiusura attiva entra nello stato
-\texttt{TIME\_WAIT} su cui torneremo fra poco.
+secondo quanto visto in \secref{sec:TCP_conn_term}; si noti che il capo della
+connessione che esegue la chiusura attiva entra nello stato
+\texttt{TIME\_WAIT}, sul cui significato torneremo fra poco.
 
 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
 e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
@@ -321,7 +323,7 @@ specifico le sue caratteristiche di velocit
 dati rispondono meglio alle esigenze che devono essere affrontate.
 
 \subsection{Lo stato \texttt{TIME\_WAIT}}
-\label{sec:TCPel_time_wait}
+\label{sec:TCP_time_wait}
 
 Come riportato da Stevens in \cite{UNP1} lo stato \texttt{TIME\_WAIT} è
 probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
@@ -329,7 +331,7 @@ comune trovare domande su come sia possibile evitare che un'applicazione resti
 in questo stato lasciando attiva una connessione ormai conclusa; la risposta è
 che non deve essere fatto, ed il motivo cercheremo di spiegarlo adesso.
 
-Come si è visto nell'esempio precedente (vedi \figref{fig:TPCel_conn_example})
+Come si è visto nell'esempio precedente (vedi \figref{fig:TCP_conn_example})
 \texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che
 esegue la chiusura attiva resta prima di passare alla chiusura definitiva
 della connessione. Il tempo in cui l'applicazione resta in questo stato deve
@@ -365,7 +367,7 @@ capisce il perch
 durata di questo stato.
 
 Il primo dei due motivi precedenti si può capire tornando a
-\figref{fig:TPCel_conn_example}: assumendo che l'ultimo ACK della sequenza
+\figref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza
 (quello del capo che ha eseguito la chiusura attiva) vanga perso, chi esegue
 la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per
 questo motivo chi esegue la chiusura attiva deve mantenere lo stato della
@@ -380,9 +382,9 @@ motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
 dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale
 ritrasmissione in caso di perdita.
 
-Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
-gli scenari in cui accade che i pacchetti si possono perdere nella rete o
-restare intrappolati, per poi riemergere.
+Il secondo motivo è più complesso da capire, e necessita di una spiegazione
+degli scenari in cui accade che i pacchetti si possano perdere nella rete o
+restare intrappolati, per poi riemergere in un secondo tempo.
 
 Il caso più comune in cui questo avviene è quello di anomalie
 nell'instradamento; può accadere cioè che un router smetta di funzionare o che
@@ -394,10 +396,10 @@ pacchetti verso un'altro e quest'ultimo li rispedisce indietro, o li manda ad
 un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
 cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
 
-Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
-non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
-stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
-destinazione. 
+Se uno di questi pacchetti intrappolati è un segmento TCP chi l'ha inviato,
+non ricevendo un ACK in risposta, provvederà alla ritrasmissione e se nel
+frattempo sarà stata stabilita una strada alternativa il pacchetto ritrasmesso
+giungerà a destinazione.
 
 Ma se dopo un po' di tempo (che non supera il limite dell'MSL, dato che
 altrimenti verrebbe ecceduto il TTL) l'anomalia viene a cessare il circolo di
@@ -407,35 +409,36 @@ questo 
 
 Allora per capire la seconda ragione per l'esistenza dello stato
 \texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una
-connessione fra l'IP 195.110.112.236 porta 1550 e l'IP 192.84.145.100 porta
-22, che questa venga chiusa e che poco dopo si ristabilisca la stessa
-connessione fra gli stessi IP sulle stesse porte (quella che viene detta,
-essendo gli stessi porte e numeri IP, una nuova \textsl{incarnazione} della
-connessione precedente); in questo caso ci si potrebbe trovare con dei
-pacchetti duplicati relativi alla precedente connessione che riappaiono nella
-nuova.
+connessione fra l'IP \texttt{195.110.112.236} porta 1550 e l'IP
+\texttt{192.84.145.100} porta 22, che questa venga chiusa e che poco dopo si
+ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte
+(quella che viene detta, essendo gli stessi porte e numeri IP, una nuova
+\textsl{incarnazione} della connessione precedente); in questo caso ci si
+potrebbe trovare con dei pacchetti duplicati relativi alla precedente
+connessione che riappaiono nella nuova.
 
 Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
-creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
+creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
 per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
 tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
 nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
-sicuri che lo stesso avvenga le risposte nella direzione opposta.
+sicuri che lo stesso avvenga per le risposte nella direzione opposta.
 
-In questo modo il TCP si assicura che quando una viene creata una nuova
-connessione tutti gli eventuali segmenti residui di una precedente connessione
-che possono causare disturbi sono stati eliminati dalla rete.
+In questo modo, prima che venga creata una nuova connessione, il protocollo
+TCP si assicura che tutti gli eventuali segmenti residui di una precedente
+connessione, che potrebbero causare disturbi, siano stati eliminati dalla
+rete.
 
 
 \subsection{I numeri di porta}
-\label{sec:TCPel_port_num}
+\label{sec:TCP_port_num}
 
-In un ambiente multitasking in un dato momento più processi possono dover
-usare sia UDP che TCP, e ci devono poter essere più connessioni in
-contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
-protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
-vedere in \secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle
-strutture degli indirizzi del socket.
+In un ambiente multitasking in un dato momento più processi devono poter usare
+sia UDP che TCP, e ci devono poter essere più connessioni in contemporanea.
+Per poter tenere distinte le diverse connessioni entrambi i protocolli usano i
+\textsl{numeri di porta}, che fanno parte, come si può vedere in
+\secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle strutture
+degli indirizzi del socket.
 
 Quando un client contatta un server deve poter identificare con quale dei vari
 possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
@@ -453,12 +456,13 @@ usate solo per la durata della connessione, e l'unico requisito che deve
 essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
 
 La lista delle porte conosciute è definita dall'RFC~1700 che contiene l'elenco
-delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
-ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
-\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
-file \file{/etc/services} contiene un analogo elenco, con la corrispondenza
-fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
-in tre intervalli:
+delle porte assegnate dalla IANA (la \textit{Internet Assigned Number
+  Authority}) ma l'elenco viene costantemente aggiornato e pubblicato su
+internet (una versione corrente si può trovare all'indirizzo
+\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}); inoltre
+in un sistema unix-like un analogo elenco viene mantenuto nel file
+\file{/etc/services}, con la corrispondenza fra i vari numeri di porta ed il
+nome simbolico del servizio.  I numeri sono divisi in tre intervalli:
 
 \begin{enumerate}
 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
@@ -481,19 +485,19 @@ in tre intervalli:
 
 In realtà rispetto a quanto indicato nell'RFC~1700 i vari sistemi hanno fatto
 scelte diverse per le porte effimere, in particolare in
-\figref{fig:TCPel_port_alloc} sono riportate quelle di BSD, Solaris e Linux.
-Nel caso di Linux poi la scelta fra i due intervalli possibili viene fatta
-dinamicamente a seconda della memoria a disposizione del kernel per gestire le
-relative tabelle.
+\figref{fig:TCP_port_alloc} sono riportate quelle di BSD e Linux.  Nel caso di
+Linux poi la scelta fra i due intervalli possibili viene fatta dinamicamente a
+seconda della memoria a disposizione del kernel per gestire le relative
+tabelle.
 
 \begin{figure}[!htb]
   \centering
   \includegraphics[width=15cm]{img/port_alloc}  
-  \caption{Allocazione dei numeri di porta}
-  \label{fig:TCPel_port_alloc}
+  \caption{Allocazione dei numeri di porta.}
+  \label{fig:TCP_port_alloc}
 \end{figure}
 
-I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
+I sistemi Unix hanno inoltre il concetto di \textsl{porte riservate} (che
 corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
 porte conosciute). La loro caratteristica è che possono essere assegnate a un
 socket solo da un processo con i privilegi di root, per far si che solo
@@ -511,25 +515,26 @@ Data una connessione TCP si suole chiamare \textit{socket pair}\footnote{da
   \func{socketpair} che fanno riferimento ad una coppia di socket sulla stessa
   macchina, non ai capi di una connessione TCP.} la combinazione dei quattro
 numeri che definiscono i due capi della connessione e cioè l'indirizzo IP
-locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota;
-questa combinazione, che scriveremo usando una notazione del tipo
-(195.110.112.152:22, 192.84.146.100:20100), identifica univocamente una
-connessione su internet.  Questo concetto viene di solito esteso anche a UDP,
-benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
-programma \cmd{netstat} permette di visualizzare queste informazioni nei campi
-\textit{Local Address} e \textit{Foreing Address}.
+locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota.
+Questa combinazione, che scriveremo usando una notazione del tipo
+(\texttt{195.110.112.152:22}, \texttt{192.84.146.100:20100}), identifica
+univocamente una connessione su internet.  Questo concetto viene di solito
+esteso anche a UDP, benché in questo caso non abbia senso parlare di
+connessione. L'utilizzo del programma \cmd{netstat} permette di visualizzare
+queste informazioni nei campi \textit{Local Address} e \textit{Foreing
+  Address}.
 
 
 \subsection{Le porte ed il modello client/server}
-\label{sec:TCPel_port_cliserv}
+\label{sec:TCP_port_cliserv}
 
 Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
 che fare con un'applicazione client/server (come quella che scriveremo in
-\secref{sec:TCPel_cunc_serv}) esamineremo cosa accade con le connessioni nel
+\secref{sec:TCP_cunc_daytime}) esamineremo cosa accade con le connessioni nel
 caso di un server TCP che deve gestire connessioni multiple.
 
-Se eseguiamo un \cmd{netstat} su una macchina di prova (che supponiamo avere
-indirizzo 195.110.112.152) potremo avere un risultato del tipo:
+Se eseguiamo un \cmd{netstat} su una macchina di prova (il cui indirizzo sia
+\texttt{195.110.112.152}) potremo avere un risultato del tipo:
 \begin{verbatim}
 Active Internet connections (servers and established)
 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
@@ -540,39 +545,41 @@ tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
 essendo presenti e attivi un server ssh, un server di posta e un DNS per il
 caching locale.
 
-Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
-mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
+Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva,
+mettendosi in ascolto sulla porta 22 riservata a questo servizio, e che si è
 posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
-associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
-equivalente all'asterisco utilizzato per il numero di porta ed indica il
-valore generico, e corrisponde al valore \const{INADDR\_ANY} definito in
-\file{arpa/inet.h}.
-
-Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
-specificati; in questo caso la \textit{socket pair} associata al socket può
-essere indicata come (*:22, *:*), usando l'asterisco anche per gli indirizzi
-come carattere di \textit{wildchard}. 
-
-In genere avendo le macchine associato un solo IP ci si può chiedere che senso
-abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
-anche macchine che hanno più di un indirizzo IP (il cosiddetto
-\textit{multihoming}) in questo modo si possono accettare connessioni
-indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
-con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
-solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
-caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
-loopback.
-
-Una volta che ci si vorrà collegare a questa macchina da un'altra posta
-all'indirizzo 192.84.146.100 si potrà lanciare un client \cmd{ssh} per
-creare una connessione verso la precedente, e il kernel assocerà al suddetto
-una porta effimera che per esempio potrà essere la 21100, la connessione
-allora sarà espressa dalla socket pair (192.84.146.100:21100,
-195.110.112.152.22).
+associati alle interfacce locali. La notazione \texttt{0.0.0.0} usata da
+\cmd{netstat} è equivalente all'asterisco utilizzato per il numero di porta,
+indica il valore generico, e corrisponde al valore \const{INADDR\_ANY}
+definito in \file{arpa/inet.h} (vedi \ref{tab:TCP_ipv4_addr}).
+
+Inoltre si noti come la porta e l'indirizzo di ogni eventuale connessione
+esterna non sono specificati; in questo caso la \textit{socket pair} associata
+al socket potrebbe essere indicata come (\texttt{*:22}, \texttt{*:*}), usando
+anche per gli indirizzi l'asterisco come carattere che indica il valore
+generico.
+
+Dato che in genere una macchina è associata ad un solo indirizzo IP, ci si può
+chiedere che senso abbia l'utilizzo dell'indirizzo generico per specificare
+l'indirizzo locale; ma a parte il caso di macchine che hanno più di un
+indirizzo IP (il cosiddetto \textit{multihoming}) esiste sempre anche
+l'indirizzo di loopback, per cui con l'uso dell'indirizzo generico si possono
+accettare connessioni indirizzate verso uno qualunque degli indirizzi IP
+presenti. Ma, come si può vedere nell'esempio con il DNS che è in ascolto
+sulla porta 53, è possibile anche restringere l'accesso ad uno specifico
+indirizzo, cosa che nel caso è fatta accettando solo connessioni che arrivino
+sull'interfaccia di loopback.
+
+Una volta che ci si vorrà collegare a questa macchina da un'altra, per esempio
+quella con l'indirizzo \texttt{192.84.146.100}, si dovrà lanciare su
+quest'ultima un client \cmd{ssh} per creare una connessione, e il kernel gli
+assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà
+espressa dalla socket pair (\texttt{192.84.146.100:21100},
+\texttt{195.110.112.152:22}).
 
 Alla ricezione della richiesta dal client il server creerà un processo figlio
 per gestire la connessione, se a questo punto eseguiamo nuovamente il
-programma netstat otterremo come risultato:
+programma \cmd{netstat} otteniamo come risultato:
 \begin{verbatim}
 Active Internet connections (servers and established)
 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
@@ -583,13 +590,14 @@ tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
 \end{verbatim}
 
 Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
-c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
+c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che utilizza anch'esso
 la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
 il processo figlio gestisce la connessione mentre il padre resta in ascolto
 sul socket originale.
 
-Se a questo punto lanciamo un'altra volta il client ssh per una seconda
-connessione quello che otterremo usando netstat sarà qualcosa del genere:
+Se a questo punto lanciamo un'altra volta il client \cmd{ssh} per una seconda
+connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
+genere:
 \begin{verbatim}
 Active Internet connections (servers and established)
 Proto Recv-Q Send-Q Local Address           Foreign Address         State      
@@ -599,50 +607,31 @@ tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
 tcp        0      0 195.110.112.152:22      192.84.146.100:21100    ESTABLISHED
 tcp        0      0 195.110.112.152:22      192.84.146.100:21101    ESTABLISHED
 \end{verbatim}
-cioè il client effettuerà la connessione usando un'altra porta effimera, con
+cioè il client effettuerà la connessione usando un'altra porta effimera: con
 questa sarà aperta la connessione, ed il server creerà un'altro processo
-figlio sarà creato per gestirla.
+figlio per gestirla.
 
-Tutto ciò mostra come TCP, per poter gestire le connessioni con un server
+Tutto ciò mostra come il TCP, per poter gestire le connessioni con un server
 concorrente, non può suddividere i pacchetti solo sulla base della porta di
 destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
 compresa la porta dell'indirizzo remoto.  E se andassimo a vedere quali sono i
-processi a cui fanno riferimento i vari socket vedremmo che i pacchetti che
-arrivano dalla porta remota 21100 vanno al primo figlio e quelli che arrivano
-alla porta 21101 al secondo.
+processi\footnote{ad esempio con il comando \cmd{fuser}, o con \cmd{lsof}.} a
+cui fanno riferimento i vari socket vedremmo che i pacchetti che arrivano
+dalla porta remota 21100 vanno al primo figlio e quelli che arrivano alla
+porta 21101 al secondo.
 
 
 \section{Le funzioni dei socket TCP}
-\label{sec:TCPel_functions}
+\label{sec:TCP_functions}
 
 In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
-l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
-\secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}) con l'eccezione
-della funzione \func{socket} che è già stata esaminata in dettaglio in
-\secref{sec:sock_socket}.
-
-In \figref{fig:TCPel_cliserv_func} abbiamo un tipico schema di funzionamento
-di un'applicazione client-server che usa i socket TCP: prima il server viene
-avviato ed in seguito il client si connette, in questo caso, a differenza di
-quanto accadeva con gli esempi elementari del \capref{cha:network} si assume
-che sia il client ad effettuare delle richieste a cui il server risponde, il
-client notifica poi di avere concluso inviando un end-of-file a cui il server
-risponderà anche lui chiudendo la connessione per aspettarne una nuova.
-
-\begin{figure}[!htb]
-  \centering
-
-  \caption{Struttura delle funzioni dei socket per una semplice applicazione
-    client/server su TCP.}
-  \label{fig:TCPel_cliserv_func}
-\end{figure}
-
-Useremo questo schema anche per l'esempio di reimplementazione del servizio
-\texttt{daytime} che illustreremo in \secref{sec:TCPel_cunc_serv}.
+l'uso dei socket TCP, con l'eccezione della funzione \func{socket} che è già
+stata esaminata in dettaglio nel capitolo precedente in
+\secref{sec:sock_socket}. 
 
 
 \subsection{La funzione \func{bind}}
-\label{sec:TCPel_func_bind}
+\label{sec:TCP_func_bind}
 
 La funzione \funcd{bind} assegna un indirizzo locale ad un socket. È usata
 cioè per specificare la prima parte dalla socket pair. Viene usata sul lato
@@ -653,22 +642,28 @@ ci si porr
   
   Assegna un indirizzo ad un socket.
   
-  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
-    errore; in caso di errore la variabile \var{errno} viene impostata secondo
-    seguenti codici di errore:
+  \bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore;
+    in caso di errore la variabile \var{errno} viene impostata secondo i
+    seguenti codici di errore:
   \begin{errlist}
   \item[\errcode{EBADF}] il file descriptor non è valido.
   \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato.
   \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
   \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
     sufficienti privilegi.
-  \end{errlist}}
+  \item[\errcode{EADDRNOTAVAIL}] Il tipo di indirizzo specificato non è
+    disponibile.
+  \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
+  \end{errlist}
+  ed anche \errval{EFAULT} e per i socket di tipo \const{AF\_UNIX},
+  \errval{ENOTDIR}, \errval{ENOENT}, \errval{ENOMEM}, \errval{ELOOP},
+  \errval{ENOSR} e \errval{EROFS}.}
 \end{prototype}
 
 Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
 \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
 l'indirizzo (locale) del socket e la dimensione della struttura che lo
-contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
+contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}. 
 
 Con il TCP la chiamata \func{bind} permette di specificare l'indirizzo, la
 porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
@@ -689,26 +684,26 @@ diventer
 socket, mentre per un server TCP questo restringerà l'accesso al socket solo
 alle connessioni che arrivano verso tale indirizzo.
 
-Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
-kernel sceglie l'indirizzo di origine quando viene effettuata la connessione
-sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
-dalle regole di instradamento usate per raggiungere il server).
-Se un server non specifica il suo indirizzo locale il kernel userà come
-indirizzo di origine l'indirizzo di destinazione specificato dal SYN del
-client. 
-
-Per specificare un indirizzo generico con IPv4 si usa il valore
-\const{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
-è pari a zero, nell'esempio \figref{fig:net_serv_code} si è usata
-un'assegnazione immediata del tipo:
+Normalmente un client non specifica mai l'indirizzo di un socket, ed il kernel
+sceglie l'indirizzo di origine quando viene effettuata la connessione, sulla
+base dell'interfaccia usata per trasmettere i pacchetti, (che dipende dalle
+regole di instradamento usate per raggiungere il server).  Se un server non
+specifica il suo indirizzo locale il kernel userà come indirizzo di origine
+l'indirizzo di destinazione specificato dal SYN del client.
+
+Per specificare un indirizzo generico, con IPv4 si usa il valore
+\const{INADDR\_ANY}, il cui valore, come accennato in
+\secref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
+\figref{fig:TCP_serv_code} si è usata un'assegnazione immediata del tipo:
 \includecodesnip{listati/serv_addr_sin_addr.c}
 
 Si noti che si è usato \func{htonl} per assegnare il valore
-\const{INADDR\_ANY}, benché essendo questo pari a zero il riordinamento sia
+\const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
 inutile.  Si tenga presente comunque che tutte le costanti \val{INADDR\_}
-(riportate in ) sono definite secondo l'ordinamento della macchina, ed anche
-se esse possono essere invarianti rispetto all'ordinamento, è comunque buona
-norma usare sempre la funzione \func{htonl}.
+(riportate in \tabref{tab:TCP_ipv4_addr}) sono definite secondo
+l'\textit{endianess} della macchina, ed anche se esse possono essere
+invarianti rispetto all'ordinamento dei bit, è comunque buona norma usare
+sempre la funzione \func{htonl}.
 
 \begin{table}[htb]
   \centering
@@ -726,7 +721,7 @@ norma usare sempre la funzione \func{htonl}.
     \hline    
   \end{tabular}
   \caption{Costanti di definizione di alcuni indirizzi generici per IPv4.}
-  \label{tab:TCPel_ipv4_addr}
+  \label{tab:TCP_ipv4_addr}
 \end{table}
 
 L'esempio precedente funziona correttamente con IPv4 poiché che l'indirizzo è
@@ -738,16 +733,15 @@ costante come operando a destra in una assegnazione.
 Per questo motivo nell'header \file{netinet/in.h} è definita una variabile
 \const{in6addr\_any} (dichiarata come \direct{extern}, ed inizializzata dal
 sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
-assegnazione del tipo:
-\includecodesnip{listati/serv_addr_sin6_addr.c}
-in maniera analoga si può utilizzare la variabile \const{in6addr\_loopback}
-per indicare l'indirizzo di \textit{loopback}, che a sua volta viene
-inizializzata staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}.
+assegnazione del tipo: \includecodesnip{listati/serv_addr_sin6_addr.c} in
+maniera analoga si può utilizzare la variabile \const{in6addr\_loopback} per
+indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata
+staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}.
 
 
 
 \subsection{La funzione \func{connect}}
-\label{sec:TCPel_func_connect}
+\label{sec:TCP_func_connect}
 
 La funzione \funcd{connect} è usata da un client TCP per stabilire la
 connessione con un server TCP, il prototipo della funzione è il seguente:
@@ -788,7 +782,7 @@ socket, gi
 
 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
 numero di porta del server a cui ci si vuole connettere, come mostrato
-nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
+nell'esempio \secref{sec:TCP_cli_sample} usando le funzioni illustrate in
 \secref{sec:sock_addr_func}.
 
 Nel caso di socket TCP la funzione \func{connect} avvia il \textit{three way
@@ -849,15 +843,15 @@ necessario effettuare una \func{bind}.
 
 
 \subsection{La funzione \func{listen}}
-\label{sec:TCPel_func_listen}
+\label{sec:TCP_func_listen}
 
-La funzione \funcd{listen} è usata per usare un socket in modalità passiva,
-cioè, come dice il nome, per metterlo in ascolto di eventuali connessioni; in
+La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
+come dice il nome, per metterlo in ascolto di eventuali connessioni; in
 sostanza l'effetto della funzione è di portare il socket dallo stato
 \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si chiama la funzione in
 un server dopo le chiamate a \func{socket} e \func{bind} e prima della
-chiamata ad \func{accept}. Il prototipo della funzione come definito dalla
-pagina di manuale è:
+chiamata ad \func{accept}. Il prototipo della funzione, come definito dalla
+pagina di manuale, è:
 \begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
   Pone un socket in attesa di una connessione.
   
@@ -887,32 +881,41 @@ Per capire meglio il significato di tutto ci
 con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
 infatti vengono mantenute due code:
 \begin{enumerate}
-\item Una coda delle connessioni incomplete (\textit{incomplete connection
-    queue} che contiene un ingresso per ciascun socket per il quale è arrivato
-  un SYN ma il three way handshake non si è ancora concluso.  Questi socket
-  sono tutti nello stato \texttt{SYN\_RECV}.
-\item Una coda delle connessioni complete (\textit{complete connection queue}
+\item La coda delle connessioni incomplete (\textit{incomplete connection
+    queue} che contiene un riferimento per ciascun socket per il quale è
+  arrivato un SYN ma il \textit{three way handshake} non si è ancora concluso.
+  Questi socket sono tutti nello stato \texttt{SYN\_RECV}.
+\item La coda delle connessioni complete (\textit{complete connection queue}
   che contiene un ingresso per ciascun socket per il quale il three way
   handshake è stato completato ma ancora \func{accept} non è ritornata.
   Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
 \end{enumerate}
 
-Lo schema di funzionamento è descritto in \figref{fig:TCPel_xxx}, quando
-arriva un SYN da un client il server crea una nuova entrata nella coda delle
-connessioni incomplete, e poi risponde con il SYN$+$ACK. La entrata resterà
+Lo schema di funzionamento è descritto in \figref{fig:TCP_listen_backlog}:
+quando arriva un SYN da un client il server crea una nuova voce nella coda
+delle connessioni incomplete, e poi risponde con il SYN$+$ACK. La voce resterà
 nella coda delle connessioni incomplete fino al ricevimento dell'ACK dal
 client o fino ad un timeout. Nel caso di completamento del three way handshake
-l'entrata viene sostata nella coda delle connessioni complete. Quando il
-processo chiama la funzione \func{accept} (vedi
-\secref{sec:TCPel_func_accept}) la prima entrata nella coda delle connessioni
-complete è passata al programma, o, se la coda è vuota, il processo viene
-posto in attesa e risvegliato all'arrivo della prima connessione completa.
+la voce viene spostata nella coda delle connessioni complete.  Quando il
+processo chiama la funzione \func{accept} (vedi \secref{sec:TCP_func_accept})
+la prima voce nella coda delle connessioni complete è passata al programma, o,
+se la coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo
+della prima connessione completa.
+
+\begin{figure}[htb]
+  \centering
+  \includegraphics[width=10cm]{img/tcp_listen_backlog}  
+  \caption{Schema di funzionamento delle code delle connessioni complete ed
+    incomplete.}
+  \label{fig:TCP_listen_backlog}
+\end{figure}
 
 Storicamente il valore del parametro \param{backlog} era corrispondente al
-massimo valore della somma del numero di entrate possibili per ciascuna di
-dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
-valore, e provvede una tabella con i risultati ottenuti con vari kernel,
-compreso Linux 2.0, che mostrano le differenze fra diverse implementazioni. 
+massimo valore della somma del numero di voci possibili per ciascuna delle due
+code. Stevens in \cite{UNP1} riporta che BSD ha sempre applicato un fattore di
+1.5 a detto valore, e fornisce una tabella con i risultati ottenuti con vari
+kernel, compreso Linux 2.0, che mostrano le differenze fra diverse
+implementazioni.
 
 In Linux il significato di questo valore è cambiato a partire dal kernel 2.2
 per prevenire l'attacco chiamato \textit{syn flood}. Questo si basa
@@ -925,13 +928,14 @@ fatto ulteriori connessioni.
 Per ovviare a questo il significato del \param{backlog} è stato cambiato a
 indicare la lunghezza della coda delle connessioni complete. La lunghezza
 della coda delle connessioni incomplete può essere ancora controllata usando
-la \func{sysctl} o scrivendola direttamente in
-\file{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
+la funzione \func{sysctl} con il parametro \const{NET\_TCP\_MAX\_SYN\_BACKLOG}
+o scrivendola direttamente in
+\file{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}.  Quando si attiva la
 protezione dei syncookies però (con l'opzione da compilare nel kernel e da
-attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
-viene ignorato e non esiste più un valore massimo.  In ogni caso in Linux il
-valore di \param{backlog} viene troncato ad un massimo di \const{SOMAXCONN}
-se è superiore a detta costante (che di default vale 128).
+attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore viene
+ignorato e non esiste più un valore massimo.  In ogni caso in Linux il valore
+di \param{backlog} viene troncato ad un massimo di \const{SOMAXCONN} se è
+superiore a detta costante (che di default vale 128).
 
 La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
 kernel non supportavano neanche valori superiori, ma la situazione corrente è
@@ -942,31 +946,31 @@ conviene specificarlo con una costante (il cui cambiamento richiederebbe la
 ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi
 \secref{sec:proc_environ}).  
 
-Lo Stevens tratta accuratamente questo argomento, con esempi presi da casi
-reali su web server, ed in particolare evidenzia come non sia più vero che il
-compito principale della coda sia quello di gestire il caso in cui il server è
-occupato fra chiamate successive alla \func{accept} (per cui la coda più
-occupata sarebbe quella delle connessioni completate), ma piuttosto quello di
-gestire la presenza di un gran numero di SYN in attesa di concludere il
+Stevens tratta accuratamente questo argomento in \cite{UNP1}, con esempi presi
+da casi reali su web server, ed in particolare evidenzia come non sia più vero
+che il compito principale della coda sia quello di gestire il caso in cui il
+server è occupato fra chiamate successive alla \func{accept} (per cui la coda
+più occupata sarebbe quella delle connessioni completate), ma piuttosto quello
+di gestire la presenza di un gran numero di SYN in attesa di concludere il
 three way handshake.
 
-Infine va messo in evidenza che nel caso di socket TCP quando un SYN arriva
+Infine va messo in evidenza che, nel caso di socket TCP, quando un SYN arriva
 con tutte le code piene, il pacchetto deve essere ignorato. Questo perché la
 condizione in cui le code sono piene è ovviamente transitoria, per cui se il
 client ritrasmette il SYN è probabile che passato un po' di tempo possa
 trovare nella coda lo spazio per una nuova connessione. Se invece si
-rispondesse con un RST per indicare l'impossibilità di effettuare la
-connessione la chiamata a \func{connect} nel client ritornerebbe con una
+rispondesse con un RST, per indicare l'impossibilità di effettuare la
+connessione, la chiamata a \func{connect} nel client ritornerebbe con una
 condizione di errore, costringendo a inserire nell'applicazione la gestione
-dei tentativi di riconnessione che invece può essere effettuata in maniera
+dei tentativi di riconnessione, che invece può essere effettuata in maniera
 trasparente dal protocollo TCP.
 
 
 \subsection{La funzione \func{accept}}
-\label{sec:TCPel_func_accept}
+\label{sec:TCP_func_accept}
 
-La funzione \funcd{accept} è chiamata da un server TCP per gestire la
-connessione una volta che sia stato completato il three way handshake, la
+La funzione \funcd{accept} è chiamata da un server per gestire la connessione
+una volta che sia stato completato il \textit{three way handshake}, la
 funzione restituisce un nuovo socket descriptor su cui si potrà operare per
 effettuare la comunicazione. Se non ci sono connessioni completate il processo
 viene messo in attesa. Il prototipo della funzione è il seguente:
@@ -974,10 +978,10 @@ viene messo in attesa. Il prototipo della funzione 
 {int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)} 
  
   Accetta una connessione sul socket specificato.
-
+  
   \bodydesc{La funzione restituisce un numero di socket descriptor positivo in
-    caso di successo e -1 in caso di errore, nel qual caso la variabile
-    \var{errno} viene impostata ai seguenti valori:
+    caso di successo e -1 in caso di errore, nel qual caso \var{errno} viene
+    impostata ai seguenti valori:
 
   \begin{errlist}
   \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
@@ -992,129 +996,396 @@ viene messo in attesa. Il prototipo della funzione 
   \item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che
     l'allocazione della memoria è limitata dai limiti sui buffer dei socket,
     non dalla memoria di sistema.
+  \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
   \end{errlist}
   Inoltre possono essere restituiti gli errori di rete relativi al nuovo
-  socket come: \errval{EMFILE}, \errval{EINVAL}, \errval{ENOSR},
-  \errval{ENOBUFS}, \errval{EFAULT}, \errval{EPERM}, \errval{ECONNABORTED},
-  \errval{ESOCKTNOSUPPORT}, \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT},
-  \errval{ERESTARTSYS}.}
+  socket, diversi a secondo del protocollo, come: \errval{EMFILE},
+  \errval{EINVAL}, \errval{ENOSR}, \errval{ENOBUFS}, \errval{EFAULT},
+  \errval{EPERM}, \errval{ECONNABORTED}, \errval{ESOCKTNOSUPPORT},
+  \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT}, \errval{ERESTARTSYS}.}
 \end{prototype}
 
-Estrae la prima connessione relativa al socket \param{sockfd} in attesa sulla
-coda delle connessioni complete, che associa ad nuovo socket con le stesse
-caratteristiche di \param{sockfd} (restituito dalla funzione stessa).  Il
-socket originale non viene toccato. Nella struttura \param{addr} e nella
-variabile \param{addrlen} vengono restituiti indirizzo e relativa lunghezza del
-client che si è connesso.
-
-La funzione può essere usata solo con socket che supportino la connessione
-(cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
-\const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
-esplicita della connessione, (attualmente in Linux solo DECnet ha questo
-comportamento), la funzione opera solo l'estrazione dalla coda delle
-connessioni, la conferma della connessione viene fatta implicitamente dalla
-prima chiamata ad una \func{read} o una \func{write} mentre il rifiuto della
-connessione viene fatto con la funzione \func{close}.
+La funzione estrae la prima connessione relativa al socket \param{sockfd} in
+attesa sulla coda delle connessioni complete, che associa ad nuovo socket con
+le stesse caratteristiche di \param{sockfd}.  Il socket originale non viene
+toccato e resta nello stato di \texttt{LISTEN}, mentre il nuovo socket viene
+posto nello stato \texttt{ESTABLISHED}. Nella struttura \param{addr} e nella
+variabile \param{addrlen} vengono restituiti indirizzo e relativa lunghezza
+del client che si è connesso.
 
-È da chiarire che Linux presenta un comportamento diverso nella gestione degli
-errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
-\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
-di errore per \func{accept}. Inoltre la funzione non fa ereditare ai nuovi
-socket flag come \const{O\_NONBLOCK}, che devono essere rispecificati volta
-volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
-deve essere tenuto in conto per scrivere programmi portabili.
-
-I due argomenti \param{cliaddr} e \param{addrlen} (si noti che quest'ultimo è
+I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è
 passato per indirizzo per avere indietro il valore) sono usati per ottenere
 l'indirizzo del client da cui proviene la connessione. Prima della chiamata
 \param{addrlen} deve essere inizializzato alle dimensioni della struttura il
-cui indirizzo è passato come argomento in \param{cliaddr}, al ritorno della
+cui indirizzo è passato come argomento in \param{addr}; al ritorno della
 funzione \param{addrlen} conterrà il numero di byte scritti dentro
-\param{cliaddr}. Se questa informazione non interessa basterà inizializzare a
+\param{addr}. Se questa informazione non interessa basterà inizializzare a
 \val{NULL} detti puntatori.
 
 Se la funzione ha successo restituisce il descrittore di un nuovo socket
 creato dal kernel (detto \textit{connected socket}) a cui viene associata la
 prima connessione completa (estratta dalla relativa coda, vedi
-\secref{sec:TCPel_func_listen}) che il client TCP ha effettuato verso il
-socket \param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello
-creato all'inizio e messo in ascolto con \func{listen}, e non viene toccato
-dalla funzione.  Se non ci sono connessioni pendenti da accettare la funzione
-mette in attesa il processo\footnote{a meno che non si sia impostato il socket
-  per essere non bloccante (vedi \secref{sec:file_noblocking}), nel qual caso
+\secref{sec:TCP_func_listen}) che il client ha effettuato verso il socket
+\param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato
+all'inizio e messo in ascolto con \func{listen}, e non viene toccato dalla
+funzione.  Se non ci sono connessioni pendenti da accettare la funzione mette
+in attesa il processo\footnote{a meno che non si sia impostato il socket per
+  essere non bloccante (vedi \secref{sec:file_noblocking}), nel qual caso
   ritorna con l'errore \errcode{EAGAIN}.  Torneremo su questa modalità di
   operazione in \secref{sec:xxx_sock_noblock}.}  fintanto che non ne arriva
 una.
+
+La funzione può essere usata solo con socket che supportino la connessione
+(cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
+\const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
+esplicita della connessione,\footnote{attualmente in Linux solo DECnet ha
+  questo comportamento.} la funzione opera solo l'estrazione dalla coda delle
+connessioni, la conferma della connessione viene eseguita implicitamente dalla
+prima chiamata ad una \func{read} o una \func{write}, mentre il rifiuto della
+connessione viene eseguito con la funzione \func{close}.
+
+È da chiarire che Linux presenta un comportamento diverso nella gestione degli
+errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
+\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
+di errore per \func{accept}, per cui l'applicazione deve tenerne conto ed
+eventualmente ripetere la chiamata alla funzione come per l'errore di
+\errcode{EAGAIN}. Un'altra differenza con BSD è che la funzione non fa
+ereditare al nuovo socket i flag del socket originale, come
+\const{O\_NONBLOCK},\footnote{ed in generale tutti quelli che si possono
+  impostare con \func{fcntl}, vedi \secref{sec:file_fcntl}.} che devono essere
+rispecificati ogni volta. Tutto questo deve essere tenuto in conto se si
+devono scrivere programmi portabili.
+
 Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
 funzionamento di un server: in generale infatti c'è sempre un solo socket in
 ascolto, che resta per tutto il tempo nello stato \texttt{LISTEN}, mentre le
-connessioni vengono gestite dai nuovi socket ritornati da \func{accept} che
-si trovano automaticamente nello stato \texttt{ESTABLISHED} e utilizzati fino
-alla chiusura della connessione che avviene su di essi.  Si può riconoscere
-questo schema anche nell'esempio elementare in \figref{fig:net_serv_code} dove
-per ogni connessione il socket creato da \func{accept} viene chiuso dopo
-l'invio dei dati.
+connessioni vengono gestite dai nuovi socket ritornati da \func{accept}, che
+si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono
+utilizzati fino alla chiusura della connessione, che avviene su di essi.  Si
+può riconoscere questo schema anche nell'esempio elementare in
+\figref{fig:TCP_serv_code} dove per ogni connessione il socket creato da
+\func{accept} viene chiuso dopo l'invio dei dati.
 
 
 \subsection{La funzione \func{close}}
-\label{sec:TCPel_func_close}
+\label{sec:TCP_func_close}
 
-La funzione standard unix \func{close} (vedi \secref{sec:file_close}) che si
-usa sui file può essere usata con lo stesso effetto anche sui socket
-descriptor.
+La funzione standard Unix \func{close} (vedi \secref{sec:file_close}) che si
+usa sui file può essere usata con lo stesso effetto anche sui file descriptor
+associati ad un socket.
 
-L'azione standard di questa funzione quando applicata a socket è di marcarlo
-come chiuso e ritornare immediatamente al processo. Una volta chiamata il
-socket descriptor non è più utilizzabile dal processo e non può essere usato
-come argomento per una \func{write} o una \func{read} (anche se l'altro
-capo della connessione non avesse chiuso la sua parte).  Il kernel invierà
-comunque tutti i dati che ha in coda prima di iniziare la sequenza di chiusura.
+L'azione di questa funzione quando applicata a socket è di marcarlo come
+chiuso e ritornare immediatamente al processo. Una volta chiamata il socket
+descriptor non è più utilizzabile dal processo e non può essere usato come
+argomento per una \func{write} o una \func{read} (anche se l'altro capo della
+connessione non avesse chiuso la sua parte).  Il kernel invierà comunque tutti
+i dati che ha in coda prima di iniziare la sequenza di chiusura.
 
-Vedremo più avanti in \secref{sec:TCPadv_so_linger} come è possibile cambiare
+Vedremo più avanti in \secref{sec:TCP_so_linger} come è possibile cambiare
 questo comportamento, e cosa deve essere fatto perché il processo possa
 assicurarsi che l'altro capo abbia ricevuto tutti i dati.
 
-Come per i file anche per i socket descriptor viene mantenuto un numero di
-riferimenti, per cui se più di un processo ha lo stesso socket aperto
+Come per tutti i file descriptor anche per i socket viene mantenuto un numero
+di riferimenti, per cui se più di un processo ha lo stesso socket aperto
 l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
-fintanto che il numero di riferimenti non si annulla. Questo è il
-comportamento normale che ci si aspetta in un'applicazione client/server quale
-quella che illustreremo in \secref{sec:TCPel_cunc_serv}.
+fintanto che il numero di riferimenti non si annulla, questo si applica, come
+visto in \secref{sec:file_sharing}, sia ai file descriptor duplicati che a
+quelli ereditati dagli eventuali processi figli, ed è il comportamento che ci
+si aspetta in una qualunque applicazione client/server.
+
+Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura
+descritta in \secref{sec:TCP_conn_term}, si può invece usare la funzione
+\func{shutdown} su cui torneremo in seguito (vedi \secref{sec:xxx_shutdown}).
+
+
+
+\section{Un esempio di applicazione}
+\label{sec:TCP_application}
+
+Avendo introdotto le funzioni di base per la gestione dei socket, potremo
+vedere in questa sezione un esempio di applicazione elementare.  Prima di
+passare agli esempi del client e del server, inizieremo riprendendo con
+maggiori dettagli una caratteristica delle funzioni di I/O, già accennata in
+\secref{sec:file_read} e \secref{sec:file_write}, che nel caso dei socket è
+particolarmente rilevante, per poi passare agli esempi, sia di server
+iterativo, che di server concorrente.
 
-Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura si
-può usare la funzione \func{shutdown} su cui torneremo in seguito. 
 
+\subsection{Il comportamento delle funzioni di I/O}
+\label{sec:sock_io_behav}
 
+Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
+le funzioni di input/output non sempre hanno lo stesso comportamento che
+avrebbero con i normali file di dati (in particolare questo accade per i
+socket di tipo stream).
 
-\section{I server concorrenti su TCP}
-\label{sec:TCPel_cunc_serv}
+Infatti con i socket è comune che funzioni come \func{read} o \func{write}
+possano restituire in input o scrivere in output un numero di byte minore di
+quello richiesto. Come già accennato in \secref{sec:file_read} questo è un
+comportamento normale per l'I/O su file, ma con i normali file di dati il
+problema si avverte solo quando si incontra la fine del file, in generale non
+è così, e con i socket questo è particolarmente evidente.
 
-Il server \texttt{daytime} dell'esempio in \secref{sec:net_cli_sample} è un
+Quando ci si trova ad affrontare questo comportamento tutto quello che si deve
+fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di
+byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non
+sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
+\const{PIPE\_BUF} byte in una pipe (si riveda quanto detto in
+\secref{sec:ipc_pipes}).
+
+\begin{figure}[htb]
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \includecodesample{listati/FullRead.c}
+  \end{minipage} 
+  \normalsize
+  \caption{La funzione \func{FullRead}, che legge esattamente \var{count} byte
+    da un file descriptor, iterando opportunamente le letture.}
+  \label{fig:sock_FullRead_code}
+\end{figure}
+
+Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono
+definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono
+lettura e scrittura tenendo conto di questa caratteristica, ed in grado di
+ritornare dopo avere letto o scritto esattamente il numero di byte
+specificato; il sorgente è riportato rispettivamente in
+\figref{fig:sock_FullRead_code} e \figref{fig:sock_FullWrite_code} ed è
+disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
+\file{FullWrite.c}.
+
+\begin{figure}[htb]
+  \centering
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \includecodesample{listati/FullWrite.c}
+  \end{minipage} 
+  \normalsize
+  \caption{La funzione \func{FullWrite}, che scrive esattamente \var{count}
+    byte su un file descriptor, iterando opportunamente le scritture.}
+  \label{fig:sock_FullWrite_code}
+\end{figure}
+
+Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo
+fino all'esaurimento del numero di byte richiesti, in caso di errore viene
+controllato se questo è \errcode{EINTR} (cioè un'interruzione della system
+call dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
+l'errore viene ritornato al programma chiamante, interrompendo il ciclo.
+
+Nel caso della lettura, se il numero di byte letti è zero, significa che si è
+arrivati alla fine del file (per i socket questo significa in genere che
+l'altro capo è stato chiuso, e non è quindi più possibile leggere niente) e
+pertanto si ritorna senza aver concluso la lettura di tutti i byte richiesti.
+
+
+\subsection{Un primo esempio di client}
+\label{sec:TCP_cli_sample}
+
+Il primo esempio di applicazione delle funzioni viste finora (sia in
+\capref{cha:socket_intro} che in \secref{sec:TCP_functions}) è relativo alla
+creazione di un client elementare per il servizio \textit{daytime}, un
+servizio standard che restituisce l'ora locale della macchina a cui si
+effettua la richiesta, e che è assegnato alla porta 13. 
+
+In \figref{fig:TCP_cli_code} è riportata la sezione principale del codice del
+nostro client. Il sorgente completo del programma
+(\file{ElemDaytimeTCPClient.c}, che comprende il trattamento delle opzioni e
+una funzione per stampare un messaggio di aiuto) è allegato alla guida nella
+sezione dei codici sorgente e può essere compilato su una qualunque macchina
+GNU/Linux.
+
+\begin{figure}[!htb]
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \includecodesample{listati/ElemDaytimeTCPClient.c}
+  \end{minipage} 
+  \normalsize
+  \caption{Esempio di codice di un client elementare per il servizio daytime.}
+  \label{fig:TCP_cli_code}
+\end{figure}
+
+Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari;
+dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
+tutta la parte relativa al trattamento degli argomenti passati dalla linea di
+comando (effettuata con le apposite funzioni illustrate in
+\capref{sec:proc_opt_handling}).
+
+Il primo passo (\texttt{\small 14--18}) è creare un \textit{socket} TCP
+(quindi di famiglia \const{AF\_INET} e di tipo \const{SOCK\_STREAM}). La
+funzione \func{socket} ritorna il descrittore che viene usato per identificare
+il socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
+stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce
+(\texttt{\small 16}) con un codice di errore.
+
+Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
+struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
+il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è
+inizializzare tutto a zero, per poi inserire il tipo di protocollo
+(\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima
+la funzione \func{htons} per convertire il formato dell'intero usato dal
+computer a quello usato nella rete, infine \texttt{\small 23--27} si può
+utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico
+passato dalla linea di comando.
+
+A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul
+socket creato in precedenza (\texttt{\small 29}) si può stabilire la
+connessione con il server. Per questo si deve utilizzare come secondo
+argomento la struttura preparata in precedenza con il relativo indirizzo; si
+noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast.
+Un valore di ritorno della funzione negativo implica il fallimento della
+connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si
+ritorna (\texttt{\small 31}).
+
+Completata con successo la connessione il passo successivo (\texttt{\small
+  34--40}) è leggere la data dal socket; il protocollo prevede che il server
+invii sempre una stringa alfanumerica di 26 caratteri, nella forma giorno
+della settimana, mese, ora minuto e secondo, anno, seguita dai caratteri di
+teminazione \verb|\r\n|, cioè qualcosa del tipo:
+\begin{verbatim}
+Wed Apr 4 00:53:00 2001\r\n
+\end{verbatim}
+questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read}
+in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small
+  35}) con il solito carattere nullo per poter essere stampata (\texttt{\small
+  36}) sullo standard output con l'uso di \func{fputs}.
+
+Come si è già spiegato in \secref{sec:sock_io_behav} la risposta dal socket
+potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel
+caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte.  Per
+questo nel caso generale non si può mai assumere che tutti i dati arrivino con
+una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo
+in cui si continui a leggere fintanto che la funzione \func{read} non ritorni
+uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero
+minore di zero (che significa un errore nella connessione).
+
+Si noti come in questo caso la fine dei dati sia specificata dal server che
+chiude la connessione (anche questo è quanto richiesto dal protocollo); questa
+è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma
+ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco
+di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed),
+mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il
+punto essenziale è che TCP non provvede nessuna indicazione che permetta di
+marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il
+programma stesso.
+
+Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene
+  fornito direttamente dal \textsl{superdemone} \texttt{inetd}, pertanto basta
+  assicurarsi che esso sia abilitato nel relativo file di configurazione.}
+possiamo verificare il funzionamento del nostro client, avremo allora:
+\begin{verbatim}
+[piccardi@gont sources]$ ./daytime 127.0.0.1
+Mon Apr 21 20:46:11 2003
+\end{verbatim}%$
+e come si vede tutto funziona regolarmente.
+
+
+\subsection{Un primo esempio di server}
+\label{sec:TCP_serv_sample}
+
+Dopo aver illustrato il client daremo anche un esempio di un server
+elementare, che sia anche in grado di rispondere al precedente client. Come
+primo esempio realizzeremo un server iterativo, in grado di fornire una sola
+risposta alla volta. Il codice del programma è nuovamente mostrato in
+\figref{fig:TCP_serv_code}, il sorgente completo
+(\file{ElemDaytimeTCPServer.c}) è allegato insieme agli altri file degli
+esempi.
+
+\begin{figure}[!htbp]
+  \footnotesize \centering
+  \begin{minipage}[c]{15cm}
+    \includecodesample{listati/ElemDaytimeTCPServer.c}
+  \end{minipage} 
+  \normalsize
+  \caption{Esempio di codice di un semplice server per il servizio daytime.}
+  \label{fig:TCP_serv_code}
+\end{figure}
+
+Come per il client si includono (\texttt{\small 1--9}) gli header necessari a
+cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small
+  14--18}) alcune costanti e le variabili necessarie in seguito, come nel caso
+precedente si sono omesse le parti relative al trattamento delle opzioni da
+riga di comando.
+
+La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente,
+come pure l'inizializzazione (\texttt{\small 25--29}) della struttura
+\struct{sockaddr\_in}, anche in questo caso (\texttt{\small 28}) si usa la
+porta standard del servizio daytime, ma come indirizzo IP si usa
+(\texttt{\small 27}) il valore predefinito \const{INET\_ANY}, che corrisponde
+ad un indirizzo generico.
+
+Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind}
+che permette di associare la precedente struttura al socket, in modo che
+quest'ultimo possa essere usato per accettare connessioni su una qualunque
+delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small
+  31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il
+programma.
+
+Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``in
+ascolto'' il socket; questo viene fatto (\texttt{\small 36}) con la funzione
+\func{listen} che dice al kernel di accettare connessioni per il socket che
+abbiamo creatp; la funzione indica inoltre, con il secondo parametro, il
+numero massimo di connessioni che il kernel accetterà di mettere in coda per
+il suddetto socket. Di nuovo in caso di errore si stampa (\texttt{\small 37})
+un messaggio, e si esce (\texttt{\small 38}) immediatamente.
+
+La chiamata a \func{listen} completa la preparazione del socket per l'ascolto
+(che viene chiamato anche \textit{listening descriptor}) a questo punto si può
+procedere con il ciclo (\texttt{\small 40--53}) principale che viene eseguito
+indefinitamente. Il primo passo è porsi (\texttt{\small 42}) in attesa di
+connessioni con la chiamata alla funzione \func{accept}, come in precedenza in
+caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce
+(\texttt{\small 44}).
+
+Il provesso resterà in stato di \textit{sleep} fin quando non arriva e viene
+accettata una connessione da un client; quando questo avviene \func{accept}
+ritorna un secondo descrittore di socket, che viene chiamato \textit{connected
+  descriptor}, e che è quello che verrà usato dalla successiva chiamata alla
+\func{write} per scrivere la risposta al client.
+
+Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente
+con una chiamata a \texttt{time}, con il quale si potrà opportunamente
+costruire (\texttt{\small 47}) la stringa con la data da trasmettere
+(\texttt{\small 48}) con la chiamata a \func{write}. Completata la
+trasmissione il nuovo socket viene chiuso (\texttt{\small 52}).  A questo
+punto il ciclo si chiude ricominciando da capo in modo da poter ripetere
+l'invio della data in risposta ad una successiva connessione.
+
+È importante notare che questo server è estremamente elementare, infatti a
+parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado
+di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un
+\textsl{server iterativo}. Inoltre esso è scritto per essere lanciato da linea
+di comando, se lo si volesse utilizzare come demone occorrerebbero le
+opportune modifiche\footnote{come una chiamata a \func{daemon} prima
+  dell'inizio del ciclo principale.} per tener conto di quanto illustrato in
+\secref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma di
+gestione della terminazione del processo, dato che tutti i file descriptor
+vengono chiusi automaticamente alla sua uscita, e che, non generando figli,
+non è necessario preoccuparsi di gestire la loro terminazione.
+
+
+\subsection{Un esempio di server \textit{daytime} concorrente}
+\label{sec:TCP_cunc_daytime}
+
+Il server \texttt{daytime} dell'esempio in \secref{sec:TCP_cli_sample} è un
 tipico esempio di server iterativo, in cui viene servita una richiesta alla
 volta; in generale però, specie se il servizio è più complesso e comporta uno
 scambio di dati più sostanzioso di quello in questione, non è opportuno
 bloccare un server nel servizio di un client per volta; per questo si ricorre
 alle capacità di multitasking del sistema.
 
-Il modo più immediato per creare un server concorrente è allora quello di
-usare la funzione \func{fork} per far creare al server per ogni richiesta da
-parte di un client un processo figlio che si incarichi della gestione della
-comunicazione.
-
-
-\subsection{Un esempio di server \textit{daytime} concorrente}
-\label{sec:TCPel_cunc_daytime}
-
-Per illustrare il meccanismo usato in generale per creare un server
-concorrente abbiamo riscritto il server \texttt{daytime} dell'esempio
-precedente in forma concorrente, inserendo anche una opzione per la stampa
-degli indirizzi delle connessioni ricevute.
+Come già visto per i server basati sui meccanismi di intercomunicazione locale
+visti in \capref{cha:IPC}, il modo più immediato per creare un server
+concorrente è quello di usare la funzione \func{fork} per creare ad ogni
+richiesta da parte di un client un processo figlio che si incarichi della
+gestione della comunicazione. Si è allora riscritto il server \texttt{daytime}
+dell'esempio precedente in forma concorrente, inserendo anche una opzione per
+la stampa degli indirizzi delle connessioni ricevute.
 
-In \figref{fig:TCPel_serv_code} è mostrato un estratto del codice, in cui si
+In \figref{fig:TCP_serv_code} è mostrato un estratto del codice, in cui si
 sono tralasciati il trattamento delle opzioni e le parti rimaste invariate
-rispetto al precedente esempio. Al solito il sorgente completo del server
-\file{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti.
+rispetto al precedente esempio (cioè tutta la parte riguardante l'apertura
+passiva del socket). Al solito il sorgente completo del server
+\file{ElemDaytimeTCPCuncServ.c} è allegato insieme ai sorgenti degli altri
+esempi.
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -1124,39 +1395,40 @@ rispetto al precedente esempio. Al solito il sorgente completo del server
   \normalsize
   \caption{Esempio di codice di un server concorrente elementare per il 
     servizio daytime.}
-  \label{fig:TCPel_serv_code}
+  \label{fig:TCP_serv_code}
 \end{figure}
 
-Come si può vedere (alle linee \texttt{\small 21--25}) la funzione
-\func{accept} stavolta è chiamata fornendo una struttura di indirizzi in cui
-saranno ritornati numero IP e porta da cui il client effettua la connessione,
-che stamperemo, se avremo abilitato il logging, sullo standard output
-(\texttt{\small 39--43}). 
+Stavolta (\texttt{\small 21--25}) la funzione \func{accept} è chiamata
+fornendo una struttura di indirizzi in cui saranno ritornati l'indirizzo IP e
+la porta da cui il client effettua la connessione, che più avanti
+(\texttt{\small 39--43}), se il logging è abilitato, stamperemo sullo standard
+output.
 
 Quando \func{accept} ritorna il server chiama la funzione \func{fork}
-(\texttt{\small 26--30}) per creare il processo figlio che effettuerà tutte le
-operazioni relative a quella connessione (\texttt{\small 31--45}), mentre il
-padre resterà in attesa di ulteriori connessioni. 
+(\texttt{\small 26--30}) per creare il processo figlio che effettuerà
+(\texttt{\small 31--45}) tutte le operazioni relative a quella connessione,
+mentre il padre resterà in attesa di ulteriori connessioni.
 
 Si noti come il figlio operi solo sul socket connesso, chiudendo
-immediatamente il socket \var{list\_fd}; mentre il padre continua ad operare
-solo sul socket in ascolto chiudendo \var{sock\_fd} dopo ciascuna
-\func{accept}. Per quanto abbiamo detto in \secref{sec:TCPel_func_close}
-queste due chiusure non causano l'innesco della sequenza di chiusura perché il
-numero di riferimenti non si è annullato.
-
-Infatti subito dopo la creazione del socket \var{list\_fd} ha una
-referenza, e lo stesso vale per \var{sock\_fd} dopo il ritorno di
-\func{accept}, ma dopo la fork i descrittori vengono duplicati nel padre e
-nel figlio per cui entrambi i socket si trovano con due referenze. Questo fa
-si che quando il padre chiude \var{sock\_fd} esso resta con una referenza
-da parte del figlio, e sarà definitivamente chiuso solo quando quest'ultimo,
-dopo aver completato le sue operazioni, chiamerà la funzione \func{close}.
+immediatamente (\texttt{\small 32}) il socket \var{list\_fd}; mentre il padre
+continua ad operare solo sul socket in ascolto chiudendo \var{sock\_fd} dopo
+(\texttt{\small 47}) ciascuna \func{accept}. Per quanto abbiamo detto in
+\secref{sec:TCP_func_close} queste due chiusure non causano l'innesco della
+sequenza di chiusura perché il numero di riferimenti al file descriptor non si
+è annullato.
+
+Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e
+lo stesso vale per \var{sock\_fd} dopo il ritorno di \func{accept}, ma dopo la
+fork i descrittori vengono duplicati nel padre e nel figlio per cui entrambi i
+socket si trovano con due referenze. Questo fa si che quando il padre chiude
+\var{sock\_fd} esso resta con una referenza da parte del figlio, e sarà
+definitivamente chiuso solo quando quest'ultimo, dopo aver completato le sue
+operazioni, chiamerà la funzione \func{close}.
 
 In realtà per il figlio non sarebbero necessarie nessuna delle due chiamate a
 \func{close} in quanto nella \func{exit} tutti i file ed i socket vengono
-chiusi, ma si è preferito effettuare la chiusura esplicitamente per avere una
-maggiore chiarezza del codice ed evitare possibili errori.
+chiusi. Tuttavia si è preferito effettuare la chiusura esplicitamente per
+avere una maggiore chiarezza del codice ed evitare possibili errori.
 
 Si noti come sia essenziale che il padre chiuda ogni volta il socket connesso
 dopo la \func{accept}; se così non fosse nessuno di questi socket sarebbe
@@ -1166,9 +1438,16 @@ esaurire i descrittori disponibili (che sono un numero limitato per ogni
 processo) e soprattutto nessuna delle connessioni con i client verrebbe
 chiusa.
 
+Si noti come anche in questo caso non si sia gestita né la terminazione del
+processo né il suo uso come demone, che tra l'altro sarenne stato
+incompatibile con l'uso della opzione di logging che stampa gli indirizzi
+delle connessioni sullo standard output. Un altro aspetto tralasciato è la
+gestione della terminazione dei processi figli, torneremo su questo più avanti
+quando tratteremo alcuni esempi di server più complessi.
+
 
 \subsection{Le funzioni \func{getsockname} e \func{getpeername}}
-\label{sec:TCPel_get_names}
+\label{sec:TCP_get_names}
 
 Queste due funzioni vengono usate per ottenere i dati relativi alla socket
 pair associata ad un certo socket; la prima è \funcd{getsockname} e
@@ -1255,6 +1534,18 @@ socket BSD fanno questa assunzione.
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
 %%% Local Variables: 
 %%% mode: latex
 %%% TeX-master: "gapil"
index a9ae7ae..a116b97 100644 (file)
Binary files a/img/port_alloc.dia and b/img/port_alloc.dia differ
diff --git a/img/tcp_listen_backlog.dia b/img/tcp_listen_backlog.dia
new file mode 100644 (file)
index 0000000..94dc8df
Binary files /dev/null and b/img/tcp_listen_backlog.dia differ
index 3c37dc0..087f5fb 100644 (file)
@@ -1286,7 +1286,7 @@ funzione chiamante un valore relativo ad uno dei suoi parametri.  Per far
 questo si usa il cosiddetto \textit{value result argument}, si passa cioè,
 invece di una normale variabile, un puntatore alla stessa; vedremo alcuni
 esempi di questa modalità nelle funzioni che gestiscono i socket (in
-\secref{sec:TCPel_functions}), in cui, per permettere al kernel di restituire
+\secref{sec:TCP_functions}), in cui, per permettere al kernel di restituire
 informazioni sulle dimensioni delle strutture degli indirizzi utilizzate,
 viene usato questo meccanismo.
 
index cd3dce8..7d0291f 100644 (file)
@@ -58,7 +58,7 @@ corpo principale, costituito dalla funzione \code{main}.  Questa si incarica
 di creare il socket, metterlo in ascolto di connessioni in arrivo e creare un
 processo figlio a cui delegare la gestione di ciascuna connessione.  Questa
 parte, riportata in \figref{fig:TCPsimpl_serv_code}, è analoga a quella vista
-nel precedente esempio esaminato in \secref{sec:TCPel_cunc_serv}.
+nel precedente esempio esaminato in \secref{sec:TCP_cunc_daytime}.
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -73,8 +73,8 @@ nel precedente esempio esaminato in \secref{sec:TCPel_cunc_serv}.
 
 La struttura di questa prima versione del server è sostanzialmente identica a
 quella dell'esempio citato, ed ad esso si applicano le considerazioni fatte in
-\secref{sec:TCPel_cunc_daytime}. Le uniche differenze rispetto all'esempio in
-\figref{fig:TCPel_serv_code} sono che in questo caso per il socket in ascolto
+\secref{sec:TCP_cunc_daytime}. Le uniche differenze rispetto all'esempio in
+\figref{fig:TCP_serv_code} sono che in questo caso per il socket in ascolto
 viene usata la porta 7 e che tutta la gestione della comunicazione è delegata
 alla funzione \code{ServEcho}.
 %  Per ogni connessione viene creato un
@@ -113,7 +113,7 @@ del processo figlio.
 
 Il codice del client è riportato in \figref{fig:TCPsimpl_client_elem}, anche
 esso ricalca la struttura del precedente client per il servizio
-\texttt{daytime} (vedi \secref{sec:net_cli_sample}) ma, come per il server, lo
+\texttt{daytime} (vedi \secref{sec:TCP_cli_sample}) ma, come per il server, lo
 si è diviso in due parti, inserendo la parte relativa alle operazioni
 specifiche previste per il protocollo \texttt{echo} in una funzione a parte.
 
@@ -129,7 +129,7 @@ specifiche previste per il protocollo \texttt{echo} in una funzione a parte.
 
 La funzione \code{main} si occupa della creazione del socket e della
 connessione (linee \texttt{\small 10--27}) secondo la stessa modalità spiegata
-in \secref{sec:net_cli_sample}, il client si connette sulla porta 7
+in \secref{sec:TCP_cli_sample}, il client si connette sulla porta 7
 all'indirizzo specificato dalla linea di comando (a cui si è aggiunta una
 elementare gestione delle opzioni non riportata in figura).
 
@@ -289,7 +289,7 @@ quando affronteremo il comportamento in caso di conclusioni anomale:
   server a cui questo risponderà con un ACK.  A questo punto il client verrà a
   trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato
   \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in
-  \secref{sec:TCPel_conn_term}).
+  \secref{sec:TCP_conn_term}).
 \item quando il server riceve il FIN la \func{read} del processo figlio che
   gestisce la connessione ritorna restituendo 0 causando così l'uscita dal
   ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio
index 8c8440f..06831e7 100644 (file)
@@ -446,7 +446,7 @@ si usa IPv4) 
 
 L'indirizzo di un socket internet (secondo IPv4) comprende l'indirizzo
 internet di un'interfaccia più un \textsl{numero di porta} (affronteremo in
-dettaglio il significato di questi numeri in \secref{sec:TCPel_port_num}).  Il
+dettaglio il significato di questi numeri in \secref{sec:TCP_port_num}).  Il
 protocollo IP non prevede numeri di porta, che sono utilizzati solo dai
 protocolli di livello superiore come TCP e UDP. Questa struttura però viene
 usata anche per i socket RAW che accedono direttamente al livello di IP, nel
@@ -458,15 +458,15 @@ specifica il \textsl{numero di porta}. I numeri di porta sotto il 1024 sono
 chiamati \textsl{riservati} in quanto utilizzati da servizi standard e
 soltanto processi con i privilegi di amministratore (con user-ID effettivo
 uguale a zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE} possono
-usare la funzione \func{bind} (che vedremo in \secref{sec:TCPel_func_bind}) su
+usare la funzione \func{bind} (che vedremo in \secref{sec:TCP_func_bind}) su
 queste porte.
 
 Il membro \var{sin\_addr} contiene un indirizzo internet, e viene acceduto sia
 come struttura (un resto di una implementazione precedente in cui questa era
 una \direct{union} usata per accedere alle diverse classi di indirizzi) che
-direttamente come intero. In \file{netinet/in.h} vengono definiti anche alcune
-costanti per alcuni indirizzi speciali, che vedremo in
-\tabref{tab:TCPel_ipv4_addr}.
+direttamente come intero. In \file{netinet/in.h} vengono definite anche alcune
+costanti che identificano alcuni indirizzi speciali, riportati in
+\tabref{tab:TCP_ipv4_addr}.
 
 Infine occorre sottolineare che sia gli indirizzi che i numeri di porta devono
 essere specificati in quello che viene chiamato \textit{network order}, cioè
@@ -957,229 +957,6 @@ Il formato usato per gli indirizzi in formato di presentazione 
 \index{socket|)}
 
 
-\section{Un esempio di applicazione}
-\label{sec:sock_appplication}
-
-Per evitare di rendere questa introduzione ai socket puramente teorica
-iniziamo con il mostrare un esempio di un client TCP elementare.  Prima di
-passare agli esempi del client e del server, ritorniamo con maggiori dettagli
-su una caratteristica delle funzioni di I/O, già accennata in
-\secref{sec:file_read} e \secref{sec:file_write}, che nel caso dei socket è
-particolarmente rilevante, e che ci tornerà utile anche in seguito.
-
-
-\subsection{Il comportamento delle funzioni di I/O}
-\label{sec:sock_io_behav}
-
-Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
-le funzioni di input/output non sempre hanno lo stesso comportamento che
-avrebbero con i normali file di dati (in particolare questo accade per i
-socket di tipo stream).
-
-Infatti con i socket è comune che funzioni come \func{read} o \func{write}
-possano restituire in input o scrivere in output un numero di byte minore di
-quello richiesto. Come già accennato in \secref{sec:file_read} questo è un
-comportamento normale per l'I/O su file, ma con i normali file di dati il
-problema si avverte solo quando si incontra la fine del file, in generale non
-è così, e con i socket questo è particolarmente evidente.
-
-Quando ci si trova ad affrontare questo comportamento tutto quello che si deve
-fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di
-byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non
-sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
-\const{PIPE\_BUF} byte in una pipe (si riveda quanto detto in
-\secref{sec:ipc_pipes}).
-
-\begin{figure}[htb]
-  \footnotesize \centering
-  \begin{minipage}[c]{15cm}
-    \includecodesample{listati/FullRead.c}
-  \end{minipage} 
-  \normalsize
-  \caption{Funzione \func{FullRead}, legge esattamente \var{count} byte da un
-    file descriptor, iterando opportunamente le letture.}
-  \label{fig:sock_FullRead_code}
-\end{figure}
-
-Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono
-definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono
-lettura e scrittura tenendo conto di questa caratteristica, ed in grado di
-ritornare dopo avere letto o scritto esattamente il numero di byte
-specificato; il sorgente è riportato rispettivamente in
-\figref{fig:sock_FullRead_code} e \figref{fig:sock_FullWrite_code} ed è
-disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
-\file{FullWrite.c}.
-
-\begin{figure}[htb]
-  \centering
-  \footnotesize \centering
-  \begin{minipage}[c]{15cm}
-    \includecodesample{listati/FullWrite.c}
-  \end{minipage} 
-  \normalsize
-  \caption{Funzione \func{FullWrite}, scrive \var{count} byte su un socket.}
-  \label{fig:sock_FullWrite_code}
-\end{figure}
-
-Come si può notare le funzioni ripetono la lettura/scrittura in un ciclo fino
-all'esaurimento del numero di byte richiesti, in caso di errore viene
-controllato se questo è \errcode{EINTR} (cioè un'interruzione della system call
-dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
-l'errore viene ritornato interrompendo il ciclo.
-
-Nel caso della lettura, se il numero di byte letti è zero, significa che si è
-arrivati alla fine del file (per i socket questo significa in genere che
-l'altro capo è stato chiuso, e non è quindi più possibile leggere niente) e
-pertanto si ritorna senza aver concluso la lettura di tutti i byte richiesti.
-
-
-
-\subsection{Un primo esempio di client}
-\label{sec:net_cli_sample}
-
-Lo scopo di questo esempio è fornire un primo approccio alla programmazione di
-rete e vedere come si usano le funzioni descritte in precedenza, alcune delle
-funzioni usate nell'esempio saranno trattate in dettaglio nel capitolo
-successivo; qui ci limiteremo a introdurre la nomenclatura senza fornire
-definizioni precise e dettagli di funzionamento che saranno trattati
-estensivamente più avanti.
-
-In \figref{fig:net_cli_code} è riportata la sezione principale del codice del
-nostro client elementare per il servizio \textit{daytime}, un servizio
-standard che restituisce l'ora locale della macchina a cui si effettua la
-richiesta.
-
-\begin{figure}[!htb]
-  \footnotesize \centering
-  \begin{minipage}[c]{15cm}
-    \includecodesample{listati/ElemDaytimeTCPClient.c}
-  \end{minipage} 
-  \normalsize
-  \caption{Esempio di codice di un client elementare per il servizio daytime.}
-  \label{fig:net_cli_code}
-\end{figure}
-
-Il sorgente completo del programma (\file{ElemDaytimeTCPClient.c}, che
-comprende il trattamento delle opzioni e una funzione per stampare un
-messaggio di aiuto) è allegato alla guida nella sezione dei codici sorgente e
-può essere compilato su una qualunque macchina Linux.
-
-Il programma anzitutto include gli header necessari (\texttt{\small 1--5});
-dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
-tutta la parte relativa al trattamento degli argomenti passati dalla linea di
-comando (effettuata con le apposite routine illustrate in
-\capref{sec:proc_opt_handling}).
-
-Il primo passo (\texttt{\small 14--18}) è creare un \textit{socket} IPv4
-(\const{AF\_INET}), di tipo TCP \const{SOCK\_STREAM}. La funzione
-\func{socket} ritorna il descrittore che viene usato per identificare il
-socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
-stampa un errore con la relativa routine e si esce.
-
-Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
-struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
-il numero della porta del servizio. Il primo passo è inizializzare tutto a
-zero, per poi inserire il tipo di protocollo e la porta (usando per
-quest'ultima la funzione \func{htons} per convertire il formato dell'intero
-usato dal computer a quello usato nella rete), infine si utilizza la funzione
-\func{inet\_pton} per convertire l'indirizzo numerico passato dalla linea di
-comando.
-
-Usando la funzione \func{connect} sul socket creato in precedenza
-(\texttt{\small 28--32}) si provvede poi a stabilire la connessione con il
-server specificato dall'indirizzo immesso nella struttura passata come secondo
-argomento, il terzo argomento è la dimensione di detta struttura. Dato che
-esistono diversi tipi di socket, si è dovuto effettuare un cast della
-struttura inizializzata in precedenza, che è specifica per i socket IPv4.  Un
-valore di ritorno negativo implica il fallimento della connessione.
-
-Completata con successo la connessione il passo successivo (\texttt{\small
-  34--40}) è leggere la data dal socket; il server invierà sempre una stringa
-di 26 caratteri della forma \verb|Wed Apr 4 00:53:00 2001\r\n|, che viene
-letta dalla funzione \func{read} e scritta su \file{stdout}.
-
-Dato il funzionamento di TCP la risposta potrà tornare in un unico pacchetto
-di 26 byte (come avverrà senz'altro nel caso in questione) ma potrebbe anche
-arrivare in 26 pacchetti di un byte.  Per questo nel caso generale non si può
-mai assumere che tutti i dati arrivino con una singola lettura, pertanto
-quest'ultima deve essere effettuata in un ciclo in cui si continui a leggere
-fintanto che la funzione \func{read} non ritorni uno zero (che significa che
-l'altro capo ha chiuso la connessione) o un numero minore di zero (che
-significa un errore nella connessione).
-
-Si noti come in questo caso la fine dei dati sia specificata dal server che
-chiude la connessione; questa è una delle tecniche possibili (è quella usata
-pure dal protocollo HTTP), ma ce ne possono essere altre, ad esempio FTP marca
-la conclusione di un blocco di dati con la sequenza ASCII \verb|\r\n|
-(carriage return e line feed), mentre il DNS mette la lunghezza in testa ad
-ogni blocco che trasmette. Il punto essenziale è che TCP non provvede nessuna
-indicazione che permetta di marcare dei blocchi di dati, per cui se questo è
-necessario deve provvedere il programma stesso.
-
-\subsection{Un primo esempio di server}
-\label{sec:net_serv_sample}
-
-Dopo aver illustrato il client daremo anche un esempio di un server
-elementare, in grado di rispondere al precedente client. Il listato è
-nuovamente mostrato in \figref{fig:net_serv_code}, il sorgente completo
-(\file{ElemDaytimeTCPServer.c}) è allegato insieme agli altri file nella
-directory \file{sources}.
-
-\begin{figure}[!htbp]
-  \footnotesize \centering
-  \begin{minipage}[c]{15cm}
-    \includecodesample{listati/ElemDaytimeTCPServer.c}
-  \end{minipage} 
-  \normalsize
-  \caption{Esempio di codice di un semplice server per il servizio daytime.}
-  \label{fig:net_serv_code}
-\end{figure}
-
-Come per il client si includono gli header necessari a cui è aggiunto quello
-per trattare i tempi, e si definiscono alcune costanti e le variabili
-necessarie in seguito (\texttt{\small 1--18}), come nel caso precedente si
-sono omesse le parti relative al trattamento delle opzioni da riga di comando.
-
-La creazione del socket (\texttt{\small 22--26}) è analoga al caso precedente,
-come pure l'inizializzazione della struttura \struct{sockaddr\_in}, anche in
-questo caso si usa la porta standard del servizio daytime, ma come indirizzo
-IP si il valore predefinito \const{INET\_ANY} che corrisponde ad un indirizzo
-generico (\texttt{\small 27--31}).
-
-Si effettua poi (\texttt{\small 32--36}) la chiamata alla funzione
-\func{bind} che permette di associare la precedente struttura al socket, in
-modo che quest'ultimo possa essere usato per accettare connessioni su una
-qualunque delle interfacce di rete locali.
-
-Il passo successivo (\texttt{\small 37--41}) è mettere ``in ascolto'' il
-socket, questo viene effettuato con la funzione \func{listen} che dice al
-kernel di accettare connessioni per il socket specificato, la funzione indica
-inoltre, con il secondo parametro, il numero massimo di connessioni che il
-kernel accetterà di mettere in coda per il suddetto socket.
-
-Questa ultima chiamata completa la preparazione del socket per l'ascolto (che
-viene chiamato anche \textit{listening descriptor}) a questo punto il processo
-è mandato in sleep (\texttt{\small 44--47}) con la successiva chiamata alla
-funzione \func{accept}, fin quando non arriva e viene accettata una
-connessione da un client.
-
-Quando questo avviene \func{accept} ritorna un secondo descrittore di socket,
-che viene chiamato \textit{connected descriptor} che è quello che viene usato
-dalla successiva chiamata alla \func{write} per scrivere la risposta al
-client, una volta che si è opportunamente (\texttt{\small 48--49}) costruita
-la stringa con la data da trasmettere. Completata la trasmissione il nuovo
-socket viene chiuso (\texttt{\small 54}).  Il tutto è inserito in un ciclo
-infinito (\texttt{\small 42--55}) in modo da poter ripetere l'invio della data
-ad una successiva connessione.
-
-È importante notare che questo server è estremamente elementare, infatti a
-parte il fatto di essere dipendente da IPv4, esso è in grado di servire solo
-un client alla volta, è cioè un \textsl{server iterativo}, inoltre esso è
-scritto per essere lanciato da linea di comando, se lo si volesse utilizzare
-come demone di sistema occorrerebbero le opportune modifiche per tener conto
-di quanto illustrato in \secref{sec:sess_daemon}.
-
-
 
 %%% Local Variables: 
 %%% mode: latex