Aggiustate le referenze e data una rilettura con qualche correzione.
authorSimone Piccardi <piccardi@gnulinux.it>
Sat, 5 May 2001 21:22:42 +0000 (21:22 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Sat, 5 May 2001 21:22:42 +0000 (21:22 +0000)
Introdotta una parte su limiti e dimesioni nel capitolo network, e dei
segnaposto per altri due paragrafi; sistemato il capitolo sui socket e
finita la seconda sezione del capitolo sui socket TCP.

elemtcp.tex
fileintro.tex
intro.tex
main.tex
network.tex
socket.tex

index eafad48..3f256c8 100644 (file)
@@ -14,31 +14,33 @@ standard \texttt{echo} su TCP.
 \section{Il funzionamento di una connessione TCP}
 \label{sec:TCPel_connession}
 
-Prima di entrare nei dettagli di come si usano le varie funzioni dei socket
-che operano con TCP, è fondamentale capire alcune basi del funzionamento del
-protocollo, ed in particolare su come si stabilisce una connessione, come la
-si conclude e qual'è il significato dei vari stati del protocollo ad essa
-connessi.
+Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
+utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
+del TCP, la conoscenza del funzionamento del protocollo è infatti essenziale
+per capire il modello di programmazione ed il funzionamento delle API.
 
-La conoscenza del funzionamento del protocollo è infatti essenziale per capire
-il modello di programmazione ed il funzionamento delle API. In tutto questo è
-di grande aiuto il programma \texttt{netstat}, che useremo per mostrare lo
-stato in cui si trova ciascuna connessione attiva.
+In particolare ci concentreremo sulle modalità con le quali il protocollo da
+inizio e conclude una connessione; faremo anche un breve accenno al
+significato di alcuni dei vari stati che il protocollo assume durante la vita
+di una connessione, che possono essere osservati per ciascun socket attivo con
+l'uso del programma \texttt{netstat}.
 
 \subsection{La creazione della connessione: il \textit{three way handushake}}
 \label{sec:TCPel_conn_cre}
 
-Lo scenario tipico che si verifica quando si deve stabilire una connessione
-TCP (lo stesso usato negli esempi elementari \ref{fig:net_cli_code} e
-\ref{fig:net_serv_code}) la successione degli eventi è la
-seguente:
-
+Il processo che porta a creare una connessione TCP è chiamato \textit{three
+  way handushake}; la successione tipica degli eventi (la stessa che si
+verifica utilizzando il codice dei due precedenti esempi elementari
+\ref{fig:net_cli_code} e \ref{fig:net_serv_code}) che porta alla creazione di
+una connessione è la seguente:
 \begin{itemize}
 \item Il server deve essere preparato per accettare le connessioni in arrivo;
-  il procedimento si chiama \textsl{apertura passiva} del socket (da
+  il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
   \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
-  \texttt{socket}, \texttt{bind} e \texttt{listen}. Infine il server chiama la
-  funzione \texttt{accept} e il processo si blocca in attesa di connessioni.
+  \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
+  passiva il server chiama la funzione \texttt{accept} e il processo si blocca
+  in attesa di connessioni.
   
 \item Il client richiede l'inizio della connessione usando la funzione
   \texttt{connect}, attraverso un procedimento che viene chiamato
@@ -55,11 +57,11 @@ seguente:
     funzioni particolari del protocollo e danno il nome al segmento, (per
     maggiori dettagli vedere \ref{cha:tcp_protocol})}, in sostanza viene
   inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
-  un numero di sequenza) e le opzioni di TCP.
+  il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
   
 \item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
   del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
-  client (e trasmettere il numero di sequenza iniziale) questo viene fatto
+  client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
   ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
   \texttt{ACK} e sono settati.
   
@@ -70,10 +72,10 @@ seguente:
   è stabilita.
 \end{itemize} 
 
-Dato che per compiere tutto questo procedimento devono essere scambiati tre
-pacchetti esso viene generalmente chiamato \textit{three way handshake}. In
-\nfig\ si è rappresentato graficamente lo sequenza di scambio dei segmenti che
-stabilisce la connessione.
+Il procedimento viene chiamato \textit{three way handshake} dato che per
+realizzarlo devono essere scambiati tre segmenti.  In \nfig\ si è
+rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce
+la connessione.
 
 % Una analogia citata da R. Stevens per la connessione TCP è quella con il
 % sistema del telefono. La funzione \texttt{socket} può essere considerata
@@ -91,17 +93,18 @@ stabilisce la connessione.
   \label{fig:TCPel_TWH}
 \end{figure}
 
-Si noti che figura si sono riportati anche i \textsl{numeri di sequenza}
-associati ai vari pacchetti; per gestire una connessione affidabile infatti il
-protocollo TCP prevede nell'header la presenza di un \textit{sequence number}
-a 32 bit che identifica a quale byte nella sequenza dello stream corrisponde
-il primo byte dei dati contenuti nel segmento.
+Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
+riportati in \curfig); 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 contenuta nel
+segmento.
 
 Il numero di sequenza di ciascun segmento viene calcolato a partire da un
-numero di sequenza iniziale generato in maniera casuale del kernel all'inizio
-della connessione e trasmesso con il SYN; l'acknowledgement di ciascun
-segmento viene effettuato dall'altro capo della connessione settando il flag
-\texttt{ACK} e restituendo nell'apposito campo dell'header un
+\textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
+all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
+ciascun segmento viene effettuato dall'altro capo della connessione settando
+il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
 \textit{acknowledge number}) pari al numero di sequenza che il ricevente si
 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
@@ -111,9 +114,10 @@ varr
 \subsection{Le opzioni TCP.}
 \label{sec:TCPel_TCP_opt}
 
-Ciascun SYN può contenere delle opzioni per il TCP (le cosiddette \textit{TCP
-  options}, che vengono inserite fra l'header e i dati) che servono a regolare
-la connessione. Normalmente vengono usate le seguenti opzioni:
+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
+dati) che servono a comunicare all'altro capo una serie di parametri utili a
+regolare la connessione. Normalmente vengono usate le seguenti opzioni:
 
 \begin{itemize}
 \item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
@@ -129,7 +133,7 @@ la connessione. Normalmente vengono usate le seguenti opzioni:
   memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può
   indicare un massimo di 65535 bytes (anche se linux usa come massimo 32767
   per evitare problemi con alcuni stack bacati che usano l'aritmetica con
-  segno per imlementare lo steck TCP); ma alcuni tipi di connessione come
+  segno per implementare lo stack TCP); ma alcuni tipi di connessione come
   quelle ad alta velocità (sopra i 45Mbits/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
@@ -140,7 +144,7 @@ la connessione. Normalmente vengono usate le seguenti opzioni:
     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 shiftare a sinistra il valore
-  della finestra annunciata).
+  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
@@ -159,8 +163,10 @@ elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
 \label{sec:TCPel_conn_term}
 
 Mentre per creare una connessione occorre un interscambio di tre segmenti, la
-procedura di chiusura ne richede ben quattro; in questo caso la successione
-degli eventi è la seguente:
+procedura di chiusura ne richede quattro; ancora una volta si può fare
+riferimento al codice degli esempi \ref{fig:net_cli_code} e
+\ref{fig:net_serv_code}, in questo caso la successione degli eventi è la
+seguente:
 
 \begin{enumerate}
 \item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
@@ -211,15 +217,18 @@ esistono situazione in cui si vuole che avvenga proprio questo, che 
 più avanti, quando parleremo della funzione \texttt{shutdown}.
 
 La emissione del FIN avviene quando il socket viene chiuso, questo però non
-avviene solo per la chiamata della funzione \texttt{close}, ma anche alla
-terminazione di un processo, il che vuol dire che se un processo viene
+avviene solo per la chiamata della funzione \texttt{close} (come in
+\ref{fig:net_serv_code}), ma anche alla terminazione di un processo (come in
+\ref{fig:net_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é nell'esempio sia il client ad eseguire la
-chusura attiva, nella realtà questa può essere eseguita da uno qualunque dei
-due capi della comunicazione, e benché questo sia il caso più comune ci sono
-dei protocolli, di cui il principale è l'HTTP, per i queli è il server ad
-effettuare la chiusura passiva.
+Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
+in \ref{sec:TCPel_echo_example}) sia 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 da \ref{fig:net_serv_code}), e
+benché quello del client sia il caso più comune 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}
@@ -227,10 +236,10 @@ effettuare la chiusura passiva.
 
 Le operazioni del TCP nella creazione e conclusione di una connessione sono
 specificate attraverso il diagramma di transizione degli stati riportato in
-\nfig. TCP prevede l'esistenza di 11 diversi stati per una connessione ed un
-insieme di regole per le transizioni da uno stato all'altro basate sullo stato
+\nfig. 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 \texttt{netstat}.
+che vengono riportati del comando \texttt{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
@@ -246,7 +255,7 @@ emette un ACK e passa allo stato \textsl{ESTABLISHED}; questo 
 finale in cui avviene la gran parte del trasferimento dei dati.
 
 Dal lato server in genere invece il passaggio che si opera con l'apertura
-passiva è quello di portare la connessione dallo stato \textsl{CLOSED} allo
+passiva è quello di portare il socket dallo stato \textsl{CLOSED} allo
 stato \textsl{LISTEN} in cui vengono accettate le connessioni.
 
 Dallo stato \textsl{ESTABLISHED} si può uscire in due modi; se un'applicazione
@@ -256,8 +265,8 @@ l'applicazione riceve un FIN nello stato \textsl{ESTABLISHED} (chiusura
 passiva) la transizione è verso lo stato \textsl{CLOSE\_WAIT}.
 
 In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
-una connessione, insieme ai vari stati che il protocollo viene ad assumere per
-i due lati, server e client. 
+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
@@ -267,8 +276,8 @@ i due lati, server e client.
 \end{figure}
 
 La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
-valore tipico per IPv4 su ethernet) il server risponde con lo stesso valore
-(ma potrebbe essere anche un valore diverso). 
+valore tipico per IPv4 su ethernet) con linux, 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
@@ -276,9 +285,9 @@ richiesta (che assumiamo stare in un singolo segmento, cio
 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 (il
-limite è dell'ordine dei 200~ms), in caso contrario si avrebbe prima
-l'emissione di un ACK e poi l'invio della risposta. 
+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 \ref{sec:TCPel_conn_term}; si noti che il capo della
@@ -286,28 +295,32 @@ connessione che esegue la chiusura attiva entra nello stato
 \textsl{TIME\_WAIT} su cui torneremo fra poco.
 
 È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
-e uno di risposta) il TCP abbia generato un totale di ulteriori otto segmenti,
-quando con l'uso di UDP sarebbero statisufficienti due pacchetti. Questo è il
-costo dell'affidabilità, passare da TCP a UDP avrebbe significato dover
-trasferire tutta una serie di dettagli (come la verifica della ricezione dei
-pacchetti) dal livello di trasporto all'interno dell'applicazione. 
-
-Pertanto è bene sempre tenere presente quali sono le esigenze che si hanno in
-una applicazione di rete, e che molte applicazioni che usano UDP lo fanno
-perché sono necessarie le sue caratteristiche di velocità e compattezza nello
-scambio dei dati.
+e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
+fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
+costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
+fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
+dettagli (come la verifica della ricezione dei pacchetti) dal livello del
+trasporto all'interno dell'applicazione.
+
+Quello che è bene sempre tenere presente è allora quali sono le esigenze che
+si hanno in una applicazione di rete, perché non è detto che TCP sia la
+miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
+già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
+per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
+specifico le sue caratteristiche di velocità e compattezza nello scambio dei
+dati rispondono meglio alle esigenze che devono essere affrontate.
 
 \subsection{Lo stato \texttt{TIME\_WAIT}}
 \label{sec:TCPel_time_wait}
 
-Come riportato da Stevens (FIXME citare) lo stato \textsl{TIME\_WAIT} è
-probabilemente uno degli aspetti meno compresi del protocollo TCP, è infatti
+Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
+probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
 comune trovare nei newsgroup 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 \curfig) \textsl{TIME\_WAIT} è
+Come si è visto nell'esempio precedente (vedi \curfig) \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 essere due volte la MSL
@@ -315,38 +328,21 @@ tempo in cui l'applicazione resta in questo stato deve essere due volte la MSL
 
 La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere
 sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere
-ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit});
-il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
+ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}).
+Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di
 IP (per maggiori dettagli vedi \ref{sec:appA_xxx}), e viene decrementato ad
-ogni passaggio da un router e quando si annulla il pacchetto viene scartato
+ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
 Siccome il numero è ad 8 bit il numero massimo di ``salti'' è di 255, pertanto
-anche se questo non è propriamente un limite sul tempo di vita, si stima che
-un pacchetto IP non possa vivere per più di MSL secondi.
+anche se il TTL (da \textit{time to live}) non è propriamente un limite sul
+tempo di vita, si stima che un pacchetto IP non possa restare nella rete per
+più di MSL secondi.
 
 Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
 raccomanda 2 minuti, linux usa 30 secondi), questo comporta una durata dello
-stato \textsl{TIME\_WAIT} da 1 a 4 minuti. 
-
-I pacchetti si possono perdere nella rete per svariati motivi, ma il caso più
-comune è quello di anomalie nell'instradamento; può accadere cioè che un
-router smetta di funzionare o che una connessione fra due router si
-interrompa, in questo caso i protocolli di instradamento dei pacchetti possono
-impiegare anche alcuni minuti prima di trovare e stabilire un percorso
-alternativo. In questo frattempo si possono creare dei circoli
-nell'instradamento (cioè casi in cui un router manda i pacchetti verso
-un'altro e quest'ultimo li rispedisce indietro, o li manda ad un terzo router
-che li rispedisce al primo) in cui restano intrappolati i pacchetti. 
-
-Assumendo che uno di questi pacchetti intrappolati sia un segmento di TCP chi
-l'ha inviato non ricevendo risposta provvederà alla ritrasmissione, e se nel
-frattempo sarà stata stabilita una strada alternativa quest'altro pacchetto
-potrà giungere a destinazione; ma se dopo un po' (non oltre il limite
-dell'MSL) la precedente connessione torna a funzionare e il circolo viene
-spezzato anche i pacchetti intrappolati potranno essere inviati alla
-destinazione finale, con la conseguenza di avere dei pacchetti duplicati che
-il TCP deve essere in grado di gestire.
-
-Lo stato \textsl{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
+stato \textsl{TIME\_WAIT} che a seconda delle implementazioni può variare fra
+1 a 4 minuti.
+
+Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi
 principali:
 \begin{itemize}
 \item implementare in maniera affidabile la terminazione della connessione
@@ -354,47 +350,81 @@ principali:
 \item consentire l'eliminazione dei segmenti duplicati dalla rete. 
 \end{itemize}
 
-La prima ragione si può capire tornando a \curfig\ assumendo che l'ultimo ACK
-vanga perso; il server allora rimanderà il suo FIN, e il client deve mantenere
-lo stato della connessione per essere in grado di reinviare l'ACK e chiudere
-correttamente la connessione. Se non fosse così la risposta del server sarebbe
-un RST (un altro tipo si segmento) che verrebbe interpretato come un errore.
+Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
+riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
+capisce il perché della scelta di un tempo pari al doppio della MSL come
+durata di questo stato.
+
+Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
+che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
+attiva) vanga perso, chi esegue la chiusura passiva non ricevndo risposta
+rimanderà un ulteriore FIN, per questo motivo chi esegue la chiusura attiva
+deve mantenere lo stato della connessione per essere in grado di reinviare
+l'ACK e chiuderla correttamente. Se non fosse così la risposta sarebbe un RST
+(un altro tipo si segmento) che verrebbe interpretato come un errore.
 
 Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della
 connessione allora deve essere in grado di affrontare la perdita di uno
 qualunque dei quattro segmenti che costituiscono la chiusura. Per questo
-motivo lo stato \textsl{TIME\_WAIT} deve essere mantenuto anche dopo l'invio
-dell'ultimo ACK per poter essere in grado di gestirne l'eventuale
+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.
 
-La seconda ragione si può capire a partire dal seguente esempio, 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 una nuova \textsl{incarnazione} della connessione
-precedente, essendo gli stessi porte e IP), in questo caso ci si potrebbe
-trovare con dei pacchetti persi relativi alla precedente connessione che
-riappaiono nella nuova. 
-
-Ma fintanto che la connessione non è tornata nello stato \textsl{CLOSED} una
-nuova incarnazione non può essere creata, per questo una connessione resta
-sempre nello stato \textsl{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 o siano stati eliminati dalla rete e altri MSL
-secondi per essere sicuri che lo stesso avvenga le risposte nella direzione
-opposta.
-
-In questo modo TCP si assicura che quando una viene creata una nuova
+
+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 caso più comune in cui questo avviene è quello di anomalie
+nell'instradamento; può accadere cioè che un router smetta di funzionare o che
+una connessione fra due router si interrompa. In questo caso i protocolli di
+instradamento dei pacchetti possono impiegare diverso temo (anche dell'ordine
+dei minuti) prima di trovare e stabilire un percorso alternativo per i
+pacchetti. Nel frattempo possono accadere casi in cui un router manda i
+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. Ma se dopo un po' di tempo (che non supera il limite dell'MSL)
+l'anomalia viene a cessare il circolo di instadamento viene spezzato i
+pacchetti intrappolati potranno essere inviati alla destinazione finale, con
+la conseguenza di avere dei pacchetti duplicati; questo è un caso che il TCP
+deve essere in grado di gestire.
+
+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.
+
+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}
+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.
+
+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 possano causare disturbi sono stati eliminati dalla rete.
+che possono causare disturbi sono stati eliminati dalla rete.
+
 
 \subsection{I numeri di porta}
-\label{sec:TCPel_ports}
+\label{sec:TCPel_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}.
+protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
+vedere in \ref{sec:sock_sa_ipv4} e \ref{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
@@ -406,10 +436,10 @@ connessioni verso tali porte.
 D'altra parte un client non ha necessità di usare un numero di porta
 specifico, per cui in genere vengono usate le cosiddette \textsl{porte
   effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
-nessun servizio noto e che vengono assegnate al client automaticamente dal
-kernel alla creazione della connessione. Queste sono dette effimere in quanto
-vengono usate solo per la durata della connessione, e l'unico requisito che
-deve essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
+nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
+creazione della connessione. Queste sono dette effimere in quanto vengono
+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'RFC1700 che contiene l'elenco
 delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
@@ -421,28 +451,28 @@ in tre intervalli:
 
 \begin{enumerate}
 \item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
-  controllate e assegnate dalla IANA, e se possibile la stessa porta è
-  assegnato allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
+  controllate e assegnate dalla IANA. Se è possibile la stessa porta è
+  assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22
   è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal
   TCP).
   
 \item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
   sono controllate dalla IANA, che però registra ed elenca chi usa queste
-  porte come servizio agli utenti, come per le precedenti si assegna una porta
+  porte come servizio agli utenti. Come per le precedenti si assegna una porta
   ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
   solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
   anche se il protocollo è implementato solo tramite TCP.
   
 \item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
   65535. La IANA non dice nulla riguardo a queste porte che pertanto
-  potrebbero essere usate come porte effimere.
+  sono i candidati naturali ad essere usate come porte effimere.
 \end{enumerate}
 
 In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
 scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
 quelle di BSD, Solaris e linux. Nel caso di linux poi la scelta fra i due
-intervali possibili viene fatta dinamicamente a seconda della memoria
-disponibile.
+intervali possibili viene fatta dinamicamente a seconda della memoria a
+disposizione del kernel per gestire le rative tabelle.
 
 \begin{figure}[!htb]
   \centering
@@ -453,25 +483,115 @@ disponibile.
 
 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) che possono essere assegnate a un socket solo da un processo
-con i privilegi di root. Questo per far si che solo l'amministratore possa
-allocare queste porte per far partire relativi servizi.
+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
+l'amministratore possa allocare queste porte per far partire relativi servizi.
 
 Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
-\texttt{rlogin}) che richiedono una connessione su una porta riservata come
-parte dell'autenticazione. Questo viene fatto tramite la funzione
-\texttt{rresvport} assegnando al socket una porta libera nell'intervallo fra
-512 e 1023.
+\texttt{rlogin}) che richiedono una connessione su una porta riservata anche
+dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
+funzione \texttt{rresvport} assegnando al socket una porta libera
+nell'intervallo fra 512 e 1023.
 
 Data una connessione TCP si suole chiamare \textit{socket pair} 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 idenfica univocamente una connessione su
-internet. Questo concetto viene di solito esteso anche a UDP, benchè in questo
-caso non abbia senso parlare di connessione. 
+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 \texttt{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}
+
+Per capire meglio l'uso delle porte e come vengono utilizzate nella
+programmazione di rete consideriamo cosa accade con una serie di esempi, se
+esguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
+indirizzo 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      
+tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
+tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
+tcp        0      0 127.0.0.1:53            0.0.0.0:*               LISTEN
+\end{verbatim}
+essendo presenti 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 è
+posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
+associati alle interfaccie 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 \texttt{INADDR\_ANY} definito in
+\texttt{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{miltihoming}) 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 \texttt{ssh} per
+creare una connessione verso la precedente, e il kernel associerà 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)$.
+
+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:
+\begin{verbatim}
+Active Internet connections (servers and established)
+Proto Recv-Q Send-Q Local Address           Foreign Address         State      
+tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
+tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
+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
+\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
+la porta 22, ma ha specificato l'indirizzo locale, e che corrisponde al socket
+con cui il processo figlio gestisce la connessione mentre il padre resta in
+ascolto.
+
+Se a questo lanciamo una seconda volta il client ssh per una seconda
+conessione quello che otterremo sarà qualcosa del genere:
+\begin{verbatim}
+Active Internet connections (servers and established)
+Proto Recv-Q Send-Q Local Address           Foreign Address         State      
+tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN
+tcp        0      0 0.0.0.0:25              0.0.0.0:*               LISTEN
+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è al client sarà stata assegnata un'altra porta effimera e con questa sarà
+aperta la connessione, ed un nuovo processo figlio sarà creato per gestirla.
+
+
+Tutto ciò mostra come TCP, per poter gestire le due connessioni, 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.
 
-Vedremo nella prossima sezione quali funzioni specificano le varie parti della
-\textit{socket pair} per un dato socket.
 
 \section{Le funzioni dei socket TCP}
 \label{sec:TCPel_functions}
@@ -479,7 +599,7 @@ Vedremo nella prossima sezione quali funzioni specificano le varie parti della
 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
 \ref{sec:net_cli_sample} e \ref{sec:net_serv_sample}) con l'eccezione della
-funzione \texttt{socket} che è stata esaminata in dettaglio in
+funzione \texttt{socket} che è già stata esaminata in dettaglio in
 \ref{sec:sock_socket}.
 
 In \nfig\ abbiamo un tipico schema di funzionamento di un'applicazione
@@ -582,7 +702,7 @@ riassunte sopra), in particolare le principali sono:
   segmento per una connessione che non esiste.
 
 \item Il SYN del client provoca l'emissione di un messaggio ICMP di
-  destinazione non raggiungibile 
+  destinazione non raggiungibile. 
   
 \end{enumerate}
 
@@ -601,3 +721,7 @@ riassunte sopra), in particolare le principali sono:
 \section{Una semplice implementazione del servizio \textt{echo} su TCP}
 \label{sec:TCPel_echo_example}
 
+
+
+
index b0779a5..dfd3081 100644 (file)
@@ -8,12 +8,11 @@ astratta che tratta le periferiche allo stesso modo degli usuali file di
 dati.
 
 Questo significa che si può accedere cioè a qualunque periferica del computer,
-dalla seriale, alla parallela, alla console, e agli stessi dischi, (unica
-eccezione le interfacce di rete, che che non rientrano bene nell'astrazione)
-attraverso i cosiddetti file di dispositivo (i \textit{device files}). Questi
-sono dei file speciali agendo sui quali i programmi possono leggere, scrivere
-e compiere operazioni direttamente sulle perferiche, usando le stesse funzioni
-che si usano per i normali file di dati.
+dalla seriale, alla parallela, alla console, e agli stessi dischi attraverso i
+cosiddetti file di dispositivo (i \textit{device files}). Questi sono dei file
+speciali agendo sui quali i programmi possono leggere, scrivere e compiere
+operazioni direttamente sulle perferiche, usando le stesse funzioni che si
+usano per i normali file di dati.
 
 In questo capitolo forniremo un'introduzione alle principali caratteristiche
 di questa interfaccia, su come essa viene implementata in linux e su come sono
@@ -185,10 +184,10 @@ di controllo di accesso molto pi
 
 Ad ogni file Unix associa sempre l'utente che ne è proprietario (il cosiddetto
 \textit{owner}) e il gruppo di appartenenza, secondo il meccanismo degli uid e
-gid spiegato in \ref{sec:intro_usergroup}, e un insieme di permessi che sono
-divisi in tre classi, e cioè attribuiti rispettivamente al proprietario, a
-qualunque utente faccia parte del gruppo cui appartiene il file, e a tutti gli
-altri utenti.
+gid spiegato in Sez.~\ref{sec:intro_usergroup}, e un insieme di permessi che
+sono divisi in tre classi, e cioè attribuiti rispettivamente al proprietario,
+a qualunque utente faccia parte del gruppo cui appartiene il file, e a tutti
+gli altri utenti.
 
 I permessi sono espressi da un insieme di 12 bit: di questi i nove meno
 significativi sono usati a gruppi di tre per indicare i permessi base di
@@ -255,6 +254,9 @@ un flusso continuo di bytes; non esiste cio
 dal sistema file di diverso contenuto o formato (come nel caso di quella fra
 file di testo e binari che c'è in windows) né c'è una strutturazione a record
 per il cosiddetto ``accesso diretto'' come nel caso del VMS.
+%  (con i kernel
+% della serie 2.4 è disponibile una forma di accesso diretto ai dischi il
+% \textit{raw access} che però non ha nulla a che fare con questo).
 
 Una seconda differenza è nel formato dei file ascii; in Unix la fine riga è
 codificata in maniera diversa da Windows o MacIntosh, in particolare il fine
@@ -323,7 +325,7 @@ stream ad un file descriptor.
 
 In generale, se non necessitano specificatamente le funzionalità di basso
 livello, è opportuno usare sempre gli stream per la loro maggiore portabilità
-essendo questi ultimi definito nello standard ISO C; l'interfaccia con i file
+essendo questi ultimi definiti nello standard ANSI C; l'interfaccia con i file
 descriptor invece segue solo lo standard POSIX.1 dei sistemi unix ed è
 pertanto di portabilità più limitata.
 
index deef466..471eada 100644 (file)
--- a/intro.tex
+++ b/intro.tex
@@ -44,7 +44,7 @@ o alle porte di input/output).
 
 Una parte del kernel, lo \textit{scheduler}, si occupa di stabilire, ad
 intervalli fissi e sulla base di un opportuno calcolo delle priorità, quale
-``processo'' (vedi \ref{cha:process}) deve essere posto in esecuzione (il
+``processo'' (vedi Cap.~\ref{cha:process}) deve essere posto in esecuzione (il
 cosidetto \textit{prehemptive scheduling}), e questo verrà comunque eseguito
 in modelità protetta; quando necessario il processo potrà accedere alle
 risorse hardware soltanto attraverso delle opportune chiamate al sistema
@@ -60,12 +60,12 @@ necessario le pagine di memoria in eccedenza.
 
 Le periferiche infine vengono viste in genere attraverso un'interfaccia
 astratta che permette di trattarle come fossero file. secondo il concetto per
-cui \textit{everything is a file}, vedi \ref{cha:files_intro}, (questo non è
-vero per le interfacce di rete, ma resta valido il concetto generale che tutto
-il lavoro di accesso e gestione a basso livello è effettuato dal kernel),
-mentre ai programmi vengono fornite solo delle routine di interfacciamento;
-essendo l'argomento principale di cui tratteremo, di esse parleremo in
-abbondanza nei capitoli successivi.
+cui \textit{everything is a file}, vedi Cap.~\ref{cha:files_intro}, (questo
+non è vero per le interfacce di rete, ma resta valido il concetto generale che
+tutto il lavoro di accesso e gestione a basso livello è effettuato dal
+kernel), mentre ai programmi vengono fornite solo delle routine di
+interfacciamento; essendo l'argomento principale di cui tratteremo, di esse
+parleremo in abbondanza nei capitoli successivi.
 
 
 \section{User space e kernel space}
@@ -76,8 +76,8 @@ essenziale fra il cosiddetto \textit{user space}, che contraddistingue
 l'ambiente in cui vengono eseguiti i programmi, e il \textit{kernel space} che
 é l'ambiente in cui viene eseguito il kernel. Ogni programma gira come se
 avesse la piena disponibilità della macchina e della memoria ed è, salvo i
-meccanismi di comunicazione previsti dall'architettura (che esamineremo in
-\ref{cha:IPC}) completamente ignaro del fatto che altri programmi possono
+meccanismi di comunicazione previsti dall'architettura (che esamineremo nel
+Cap.~\ref{cha:IPC}) completamente ignaro del fatto che altri programmi possono
 essere messi in esecuzione dal kernel.
 
 In questo non è possibile ad un singolo programma disturbare l'azione di un
@@ -193,7 +193,7 @@ In questo modo il sistema 
 dell'utente a cui appartiene ed impedire ad altri utenti di interferire con
 esso. Inoltre con questo sistema viene anche garantita una forma base di
 sicurezza interna in quanto anche l'accesso ai file (vedi
-\ref{sec:fileintr_access_ctrl}) è regolato da questo meccanismo di
+Sez.~\ref{sec:fileintr_access_ctrl}) è regolato da questo meccanismo di
 identificazione.
 
 Un utente speciale del sistema è \textit{root}, il cui uid è zero. Esso
index 2a89c02..1ab522c 100644 (file)
--- a/main.tex
+++ b/main.tex
@@ -7,6 +7,9 @@
 %% 
 \documentclass[a4paper,11pt,twoside,italian]{book}
 \usepackage[latin1]{inputenc}
+\usepackage{booktabs}
+\usepackage{pstcol}
+\usepackage{pst-node}
 \usepackage{graphicx}
 \usepackage{babel}
 \usepackage{cite}
index fc54b79..fd9f734 100644 (file)
@@ -321,7 +321,7 @@ macchine diverse conversano tramite lo stesso protocollo. Questo modello di
 funzionamento è stato stato standardizzato dalla \textit{International
   Standards Organization} (ISO) che ha preparato fin dal 1984 il Modello di
 Riferimento \textit{Open Systems Interconnection} (OSI), strutturato in sette
-livelli, secondo la tabella in \ntab.
+livelli, secondo quanto riportato in \ntab.
 
 \begin{table}[htb]
   \centering
@@ -746,4 +746,79 @@ controllo di flusso e della gestione della sequenzialit
 effettuato per entrambe le direzioni di comunicazione.
 
 Una descrizione più accurata del protocollo è fornita in appendice
-\ref{cha:tcp_protocol}.
\ No newline at end of file
+\ref{cha:tcp_protocol}.
+
+\subsection{Limiti e dimensioni riguardanti la trasmissione dei dati}
+\label{sec:net_lim_dim}
+
+Un aspetto di cui bisogna tenere conto, e che ritornerà in seguito, è che ci
+sono una serie di limiti a cui la trasmissione dei dati attraverso i vari
+livelli del protocollo deve sottostare, limiti che è opportuno tenere presente
+perché in certi casi si possono avere delle conseguenze sul comportamento
+delle applicazioni.
+
+Un elenco di questi limiti è il seguente, insieme ad un breve accenno alle
+loro origini ed alle eventuali implicazioni che possono avere:
+\begin{itemize}
+\item La dimensione massima di un pacchetti IP è di 65535 bytes, compreso
+  l'header. Questo è dovuto al fatto che la dimensione è indicata da un campo
+  apposito nell'header di IP che è lungo 16 bit (vedi
+  \ref{sec:appA_ipv4head}).
+\item La dimensione massima di un pacchetto normale di IPv6 è di 65575 bytes,
+  il campo apposito nell'header infatti è sempre a 16 bit, ma la dimensione
+  dell'header è fissa e di 40 byte e non è compresa nel valore indicato dal
+  suddetto campo. Inoltre IPv6 ha la possibilità di estendere la dimensione di
+  un pacchetto usando la \textit{jumbo payload option}.
+\item Molte reti fisiche hanno un MTU (\textit{maximum tranfer unit}) che è
+  imposta dalle modalità di funzionamento dall'hardware. Il più comune è
+  quello dell'ethernet che è pari a 1500 bytes. La MTU più piccola fra due
+  stazioni viene in genere chiamata \textit{path MTU}, e al giorno d'oggi è
+  normalmente data da ethernet; si tenga conto che non è affatto detto che sia
+  la stessa in entrambe le direzioni, anche perchè l'instradamento può essere
+  diverso.
+\end{itemize}
+
+Quando un pacchetto IP viene inviato su una interfaccia di rete e le sue
+dimensioni eccedono la MTU viene eseguita la cosiddetta
+\textit{frammentazione} (sia da IPv4 che da IPv6, anche se i pacchetti
+frammentati sono gestiti con modalità diverse\footnote{il primo usa un flag
+  nell'header, il secondo una opportuna opzione, si veda
+  \ref{cha:ip_protcol}}), i pacchetti cioè vengono spezzati in blocchi più
+piccoli che possono essere trasmessi attraverso l'interfaccia.
+
+Una delle differenze fra IPv4 e IPv6 é che per IPv6 la frammentazione può
+essere eseguita solo alla sorgente, questo vuol dire che i router IPv6 non
+frammentano i pacchetti che trasmettono (anche se possono frammentare i
+pacchetti che generano loro stessi), mentre i router IPv4 si. In ogni caso una
+volta frammentati i pacchetti possono essere riassemblati solo alla
+destinazione.
+
+Nell'header di IPv4 è previsto il flag \texttt{DF} che specifica che il
+pacchetto non deve essere frammentato; un router che riceva uno di questi
+pacchetti le cui dimensioni eccedono quelle dell'MTU della rete di
+destinazione genererà un messaggio di errore ICMPv4 di tipo
+\textit{destination unreachable, fragentation needed but DF bit set}.
+
+Dato che i router IPv6 non possono effettuare la frammentazione la ricezione
+di un pacchetto di dimensione eccessiva per la ritrasmissione genererà sempre
+un messaggio di errore ICMPv6 di tipo \textit{paket too big}.
+
+Dato che il meccanismo di frammentazione e riassemblaggio comporta
+inefficienza è opportuno che la trasmissione di grosse quantità di dati sia
+gestita in maniera oculata, TCP provvede un meccanismo automatico di 
+
+In genere il flag DF di IPv4 (e il comportamento normale di IPv6) vengono
+utilizzati per il processo della \textit{path MTU discover} (vedi RFC1191 per
+IPv4 e RFC1981 per IPv6) in cui inviando delle opportune serie di pacchetti si
+trova il \textit{path MTU}; TCP usa questo meccanismo che è opzionale per
+IPv4, ma necessario (dato che i pacchetti verrebbero bloccati) per IPv6.
+
+Infine TCP definisce una \textit{maximum segment size} MSS che annuncia
+all'altro capo la dimensione massima del segmento di dati 
+
+
+\subsection{Il passaggio dei dati in TCP}
+\label{sec:net_tcp_pass}
+
+\subsection{Il passaggio dei dati in UDP}
+\label{sec:net_udp_pass}
index 05b1af6..4d19955 100644 (file)
@@ -112,13 +112,13 @@ effettuare la comunicazione.
 
 Dati i tanti e diversi protocolli di comunicazione disponibili, esistono vari
 tipi di socket, che vengono classificati raggruppandoli in quelli che si
-chiamano \textsl{domini} (\textit{domains}).  La scelta di un dominio equivale
-in sostanza alla scelta di una famiglia di protocolli. Ciascun dominio ha un
-suo nome simbolico che convenzionalmente inizia con \texttt{PF\_} (da
-\textit{Protocol Family}, altro nome con cui si indicano i domini). 
+chiamano \textsl{domini}.  La scelta di un dominio equivale in sostanza alla
+scelta di una famiglia di protocolli. Ciascun dominio ha un suo nome simbolico
+che convenzionalmente inizia con \texttt{PF\_} da \textit{protocol family},
+altro nome con cui si indicano i domini.
 
 A ciascun tipo di dominio corrisponde un analogo nome simbolico che inizia per
-\texttt{AF\_} da \textit{Address Family}, e che identifica il formato degli
+\texttt{AF\_} da \textit{address family}, e che identifica il formato degli
 indirizzi usati in quel dominio; le man pages di linux si riferiscono a questi
 anche come \textit{name space}, (nome che però il manuale della glibc riserva
 ai domini) e che identifica il formato degli indirizzi usati in quel dominio.
@@ -140,6 +140,7 @@ protocolli disponibili sono riportate in \ntab.
   \centering
   \begin{tabular}[c]{lll}
        Nome               & Utilizzo                       & Man page   \\
+       \hline
        PF\_UNIX,PF\_LOCAL & Local communication            & unix(7)    \\
        PF\_INET           & IPv4 Internet protocols        & ip(7)      \\
        PF\_INET6          & IPv6 Internet protocols        &            \\
@@ -319,12 +320,11 @@ definiti; la struttura 
   \label{tab:sock_data_types}
 \end{table}
 
-In alcuni sistemi (per BSD a partire da 4.3BSD-reno) la struttura è
-leggermente diversa e prevede un primo membro aggiuntivo \texttt{uint8\_t
-  sin\_len} (come riportato da R. Stevens nei suoi libri). Questo campo non
-verrebbe usato direttamente dal programmatore e non è richiesto dallo standard
-Posix.1g, in Linux pertanto non sussiste. Il campo \texttt{sa\_family\_t} era
-storicamente un \texttt{unsigned short}.
+In alcuni sistemi la struttura è leggermente diversa e prevede un primo membro
+aggiuntivo \texttt{uint8\_t sin\_len} (come riportato da R. Stevens nei suoi
+libri). Questo campo non verrebbe usato direttamente dal programmatore e non è
+richiesto dallo standard Posix.1g, in linux pertanto non sussiste. Il campo
+\texttt{sa\_family\_t} era storicamente un \texttt{unsigned short}.
 
 Dal punto di vista del programmatore l'unico uso di questa struttura è quello
 di fare da riferimento per il casting, per il kernel le cose sono un po'
@@ -371,11 +371,11 @@ RAW che accedono direttamente al livello di IP, nel qual caso il numero della
 porta viene settato al numero di protocollo.
 
 Il membro \texttt{sin\_family} deve essere sempre settato; \texttt{sin\_port}
-specifica il numero di porta; i numeri di porta sotto il 1024 sono chiamati
-\textsl{riservati} in quanto utilizzati da servizi standard. Soltanto processi
-con i privilegi di root (effective uid uguale a zero) o con la capability
-\texttt{CAP\_NET\_BIND\_SERVICE} possono usare la funzione \texttt{bind} su
-queste porte.
+specifica il numero di porta (vedi \ref{sec:TCPel_port_num}; i numeri di porta
+sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da servizi
+standard. Soltanto processi con i privilegi di root (effective uid uguale a
+zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE} possono usare la
+funzione \texttt{bind} su queste porte.
 
 Il membro \texttt{sin\_addr} contiene l'indirizzo internet dell'altro capo
 della comunicazione, e viene acceduto sia come struttura (un resto di una
@@ -423,7 +423,7 @@ segue le stesse regole; il campo \texttt{sin6\_flowinfo} 
 in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
 successivi 4 bit la priorità e gli ultimi 4 sono riservati; questi valori
 fanno riferimento ad alcuni campi specifici dell'header dei pacchetti IPv6
-(vedi \ref{sec:appA_ipv6}) ed il loro uso è sperimentale. 
+(vedi \ref{sec:appA_ipv6}) ed il loro uso è sperimentale.
 
 Il campo \texttt{sin6\_addr} contiene l'indirizzo a 128 bit usato da IPv6,
 infine il campo \texttt{sin6\_scope\_id} è un campo introdotto con il kernel
@@ -433,16 +433,16 @@ Si noti che questa struttura 
 quindi occorre stare attenti a non avere fatto assunzioni riguardo alla
 possibilità di contenere i dati nelle dimensioni di quest'ultima.
 
+
 \subsection{La struttura degli indirizzi locali}
 \label{sec:sock_sa_local}
 
 I socket di tipo \texttt{PF\_UNIX} vengono usati per una comunicazione
 efficiente fra processi che stanno sulla stessa macchina; essi rispetto ai
 precedenti possono essere anche creati in maniera anonima attraverso la
-funzione \texttt{socketpair}. Quando però si vuole fare riferiemento ad uno di
-questi socket si deve usare la seguente struttura di indirizzi definita nel
-file di header \texttt{sys/un.h}.
+funzione \texttt{socketpair}. Quando però si vuole fare riferimento esplicito
+ad uno di questi socket si deve usare la seguente struttura di indirizzi
+definita nel file di header \texttt{sys/un.h}.
 
 \begin{figure}[!htbp]
   \footnotesize
@@ -463,18 +463,18 @@ mentre il campo \texttt{sun\_path} deve specificare un indirizzo; questo ha
 due forme un file (di tipo socket) nel filesystem o una stringa univoca
 (tenuta in uno spazio di nomi astratto). Nel primo caso l'indirizzo viene
 specificato come una stringa (terminata da uno zero) corrispondente al
-pathname del file; nel secondo qinvece \texttt{sun\_path} inizia con uno zero
-vegono usati i restanti bytes come stringa (senza terminazione).
+pathname del file; nel secondo invece \texttt{sun\_path} inizia con uno zero
+vengono usati i restanti bytes come stringa (senza terminazione).
 
 
-\subsection{Il passaggio delle strutture}
-\label{sec:sock_addr_pass}
+\subsection{Il passaggio delle strutture}
+\label{sec:sock_addr_pass}
 
-Come detto nelle funzioni della API dei socket le strutture degli indirizzi
-vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
-della struttura è passata come argomento, ma in questo caso la modalità del
-passaggio dipende dalla direzione del medesimo, dal processo al kernel o
-viceversa.
+Come detto nelle funzioni della API dei socket le strutture degli indirizzi
+vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
+della struttura è passata come argomento, ma in questo caso la modalità del
+passaggio dipende dalla direzione del medesimo, dal processo al kernel o
+viceversa.
 
 % In particolare le tre funzioni \texttt{bind}, \texttt{connect} e
 % \texttt{sendto} passano la struttura al kernel, in questo caso è passata
@@ -488,23 +488,33 @@ viceversa.
 \section{Le funzioni di conversione degli indirizzi}
 \label{sec:sock_addr_func}
 
-Come accennato gli indirizzi internet e i numeri di porta usati nella rete
-devono essere forniti in formato big endian. In genere la rappresentazione di
-un numbero binario in un computer può essere fatta in due modi, chiamati
-rispettivamente \textit{big endian} e \textit{little endian} a seconda di come
-i singoli bit vengono aggregati per formare le variabili intere (in diretta
-corrispondenza a come sono poi in realtà cablati sui bus interni del
-computer).
+In questa sezione tratteremo delle varie funzioni usate per manipolare gli
+indirizzi, limitandoci però agli indirizzi internet.
+
+Come accennato gli indirizzi e i numeri di porta usati nella rete devono
+essere forniti in formato opportuno (il \textit{network order}). Per capire
+cosa significa tutto ciò occorre introdurre un concetto generale che tornerà
+utile anche in seguito.
+
+
+\subsection{La \textit{endianess}}
+\label{sec:sock_endianess}
+
+La rappresentazione di un numbero binario in un computer può essere fatta in
+due modi, chiamati rispettivamente \textit{big endian} e \textit{little
+  endian} a seconda di come i singoli bit vengono aggregati per formare le
+variabili intere (in diretta corrispondenza a come sono poi in realtà cablati
+sui bus interni del computer).
 
 Per capire meglio il problema si consideri un intero a 16 bit scritto in una
 locazione di memoria posta ad un certo indirizzo. I singoli bit possono essere
 disposti un memoria in due modi, a partire dal più significativo o a partire
 dal meno significativo. Così nel primo caso si troverà il byte che contiene i
 bit più significativi all'indirizzo menzionato e il byte con i bit meno
-significativi nell'indirizzo successivo; questo ordinamento è detto little
-endian dato che il dato finale è la parte ``piccola'' del numero. Il caso
-opposto, in cui si parte dal bit meno significativo è detto per lo stesso
-motivo big endian.
+significativi nell'indirizzo successivo; questo ordinamento è detto
+\textit{little endian} dato che il dato finale è la parte ``piccola'' del
+numero. Il caso opposto, in cui si parte dal bit meno significativo è detto
+per lo stesso motivo \textit{big endian}.
 
 La \textit{endianess} di un computer dipende essenzialmente dalla architettura
 hardware usata; intel e digital usano il little endian, motorola, ibm, sun
@@ -516,16 +526,20 @@ in linux l'ordinamanento 
 cambiamenti sono possibili anche dopo che il sistema è avviato, non vengono
 mai eseguiti.
 
+\subsection{Le funzioni per il riordinamento}
+\label{sec:sock_func_ord}
+
 Il problema connesso all'endianess è che quando si passano dei dati da un tipo
-di architettura all'altra; in questo caso infatti nel passaggio i dati vengono
-interpretati in maniera diversa, e nel caso dell'esempio dell'intero a 16 bit
-ci si ritroverà con i due bytes componenti scambiati di posto, mentre in
-generale ne sarà invertito l'ordine di lettura e andranno perciò rovesciati.
+di architettura all'altra i dati vengono interpretati in maniera diversa, e ad
+esempio nel caso dell'intero a 16 bit ci si ritroverà con i due bytes in cui è
+suddiviso scambiati di posto, e ne sarà quindi invertito l'ordine di lettura
+per cui, per riavere il valore originale dovrenno essere rovesciati.
 
 Per questo motivo si usano le seguenti funzioni di conversione (i cui
 prototipi sono definiti in \texttt{netinet/in.h}) che servono a tener conto
 automaticamente della possibile differenza fra l'ordinamento usato sul
-computer e quello che viene usato nelle trasmissione sulla rete:
+computer e quello che viene usato nelle trasmissione sulla rete; queste
+funzioni sono:
 \begin{itemize}
 \item \texttt{unsigned long int htonl(unsigned long int hostlong)} 
   
@@ -559,6 +573,10 @@ fanno nulla); esse vanno sempre utilizzate per assicurare la portabilit
 codice su tutte le architetture.
 
 
+\subsection{Le funzioni \texttt{inet\_aton}, \texttt{inet\_addr} e 
+  \texttt{inet\_ntoa}}
+\label{sec:sock_func_ipv4}
+
 Un secondo insieme di funzioni di manipolazione (i cui prototipi sono definiti
 in \texttt{arpa/inet.h}) serve per passare dal formato binario usato nelle
 strutture degli indirizzi alla rappresentazione dei numeri IP che si usa
@@ -589,7 +607,7 @@ indicare la stringa. Dette funzioni sono:
   valido, non può essere usata con questa funzione; per questo motivo essa è
   generalmente deprecata in favore della precedente.
   
-\item \texttt{char *inet\_ntop(struct in\_addr addrptr)}
+\item \texttt{char *inet\_ntoa(struct in\_addr addrptr)}
   
   Converte il valore a 32 bit dell'indirizzo (espresso in network order)
   restituendo il puntatore alla stringa che contiene l'espressione in formato
@@ -597,10 +615,14 @@ indicare la stringa. Dette funzioni sono:
   statica, per cui questa funzione non è rientrante.
 \end{itemize}
 
-Le tre funzioni precedenti sono però limitate solo ad IPv4, per questo motivo
-è preferibile usare le due nuove funzioni \texttt{inet\_pton} e
+
+\subsection{Le funzioni \texttt{inet\_pton} e \texttt{inet\_ntop}}
+\label{sec:sock_conv_func_gen}
+
+Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
+motivo è preferibile usare le due nuove funzioni \texttt{inet\_pton} e
 \texttt{inet\_ntop} che possono convertire anche gli indirizzi IPv6 (secondo
-lo schema in \nfig). Anche in questo caso le lettere $n$ e $p$ sono gli
+lo schema in \nfig). Anche in questo caso le lettere $n$ e $p$ sono degli
 mnemonici per ricordare il tipo di conversione effettuata e stanno per
 \textit{presentation} e \textit{numeric}.
 
@@ -655,9 +677,11 @@ per i socket di tipo stream).
 Infatti con i socket può accadere che funzioni come \texttt{read} o
 \texttt{write} possano restituire in input o scrivere in output un numero di
 bytes minore di quello richiesto. Questo è un comportamento normale e non un
-errore, e succede perché si eccede il limite di buffer del kernel. In questo
-caso tutto quello che il programma chiamante deve fare è di ripetere la
-lettura (o scrittura) per la quantità di bytes rimanenti (lo stesso può
+errore, e succede perché si eccede in lettura o scrittura il limite di buffer
+del kernel. 
+
+In questo caso tutto quello che il programma chiamante deve fare è di ripetere
+la lettura (o scrittura) per la quantità di bytes rimanenti (lo stesso può
 avvenire scrivendo più di 4096 bytes in una pipe, dato che quello è il limite
 di solito adottato per il buffer di trasmissione del kernel).
 
@@ -734,7 +758,7 @@ Come si pu
 all'esaurimento del numero di bytes richiesti, in caso di errore viene
 controllato se questo è \texttt{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 loop.  
+l'errore viene ritornato interrompendo il loop. 
 
 Nel caso della lettura se il numero di bytes letti è zero significa che è
 arrivati alla fine del file e pertanto si ritorna senza aver concluso la