e \ref{sec:net_serv_sample}), previa una descrizione delle principali
caratteristiche del funzionamento di una connessione TCP.
-La seconda parte del capitolo sarà poi dedicata ad una riscrittura
-dell'esempio precedente per trasformarlo in una prima applicazione
-client/server semplice, ma completa, che implementi il servizio standard
-\texttt{time} su TCP (vedremo in seguito un esempio anche con UDP).
-
+La seconda parte del capitolo sarà poi dedicata alla scrittura di una prima
+semplice applicazione client/server completa, che implementi il servizio
+standard \texttt{echo} su TCP.
\section{Il funzionamento di una connessione TCP}
\label{sec:TCPel_connession}
\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'haeader, che così può
- indicare un massimo di 65535 bytes; ma alcuni tipi di connessione come
+ 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
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
protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
vengono anche dette \textit{long fat pipe options} dato che questo è il nome
che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
-elevati.
-
+elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
\subsection{La terminazione della connessione}
\label{sec:TCPel_conn_term}
la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella
sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma
esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato
-\texit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
+\textit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo
più avanti, quando parleremo della funzione \texttt{shutdown}.
La emissione del FIN avviene quando il socket viene chiuso, questo però non
terminazione di un processo, il che vuol dire 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.
+
\subsection{Un esempio di connessione}
\label{sec:TCPel_conn_dia}
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
-corrente e sul tipo di segmetno ricevuto.
+corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
+che vengono riportati del comando \texttt{netstat}.
+
+Una descrizione completa del funzionamento del protocollo va al di là degli
+obiettivi di questo libro; un approfondimento sugli aspetti principali si
+trova in \ref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
+riferimento resta (FIXME citare lo Stevens); 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 è \textsl{CLOSED}; quando una
+applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
+diventa \textsl{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
+emette un ACK e passa allo stato \textsl{ESTABLISHED}; questo è lo stato
+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
+stato \textsl{LISTEN} in cui vengono accettate le connessioni.
+
+Dallo stato \textsl{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 \textsl{FIN\_WAIT\_1}; se invece
+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.
+\begin{figure}[htb]
+ \centering
+
+ \caption{Schema dello scambio di pacchetti per un esempio di connessione}
+ \label{fig:TPCel_conn_example}
+\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).
+
+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 bytes 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 (il
+limite è dell'ordine dei 200~ms), 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
+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.
\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
+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} è
+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
+(\textit{Maximum Segment Lifetime}).
+
+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
+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
+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.
+
+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
+principali:
+\begin{itemize}
+\item implementare in maniera affidabile la terminazione della connessione
+ in entrambe le direzioni.
+\item consentire l'eliminazione dei segmenti duplicati dalla rete.
+\end{itemize}
-
-\section{I numeri di porta}
+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.
+
+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
+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
+connessione tutti gli eventuali segmenti residui di una precedente connessione
+che possano causare disturbi sono stati eliminati dalla rete.
+
+\subsection{I numeri di porta}
\label{sec:TCPel_ports}
+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}.
+
+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
+di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che
+identificano una serie di servizi noti (ad esempio la porta 22 identifica il
+servizio \texttt{ssh}) effettuati da appositi server che rispondono alle
+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.
+
+La lista delle porte conosciute è definita dall'RFC1700 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 \texttt{/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:
+
+\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
+ è 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
+ 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.
+\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.
+
+\begin{figure}[!htb]
+ \centering
+
+ \caption{Allocazione dei numeri di porta}
+ \label{fig:TCPel_port_alloc}
+\end{figure}
+
+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.
+
+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.
+
+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.
+
+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}
+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
+\ref{sec:sock_socket}.
+
+In \nfig\ 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 Cap.~\ref{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 per l'esempio di implementazione del servizio
+\texttt{echo} che illustreremo in \ref{sec:TCPel_echo_example}.
+
\subsection{La funzione \texttt{connect}}
\label{sec:TCPel_func_connect}
+La funzione \texttt{connect} è usata da un client TCP per stabilire la
+connessione con un server TCP, il prototipo della funzione, definito in
+\texttt{sys/socket.h}, è il seguente:
+
+\begin{itemize}
+\item \texttt{int connect(int sockfd, const struct sockaddr *serv_addr,
+ socklen_t addrlen) }
+
+ Il primo argomento è un file descriptor ottenuto da una precedente chiamata
+ a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
+ l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
+ socket, già descritta in \ref{sec:sock_sockaddr}.
+
+ La funzione restituisce zero in caso di successo e -1 per un errore, in caso
+ di errore. La variabile \texttt{errno} viene settata secondo i seguenti
+ codici di errore
+
+ \begin{itemize}
+ \item \texttt{EBADF} Il file descriptor non è valido.
+ \item \texttt{EFAULT} L'indirizzo della struttura di indirizzi è al di fuori
+ dello spazio di indirizzi dell'utente.
+ \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket
+ \item \texttt{EISCONN} Il socket è già connesso.
+ \item \texttt{ECONNREFUSED} Non c'è nessuno in ascolto sull'indirizzo remoto.
+ \item \texttt{ETIMEDOUT} Si è avuto timeout durante il tentativo di
+ connessione.
+ \item \texttt{ENETUNREACH} La rete non è rggiungibile/
+ \item \texttt{EADDRINUSE} L'indirizzo locale è in uso.
+ \item \texttt{EINPROGRESS} Il socket è non bloccante e la connessione non
+ può essere conclusa immediatamente.
+ \item \texttt{EALREADY} Il socket è non bloccante e un tentativo precedente
+ di connessione non si è ancora concluso.
+ \item \texttt{EAGAIN} Non ci sono più porte locali libere.
+ \item \texttt{EAFNOSUPPORT} L'indirizzo non ha una famiglia di indirizzi
+ corretta nel relativo campo.
+ \item \texttt{EACCESS, EPERM}
+ \end{itemize}
+\end{itemize}
+
+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 \ref{sec:net_cli_sample} usando le funzioni illustrate in
+\ref{sec:sock_addr_func}.
+
+Nel caso di socket TCP la funzione \texttt{connect} avvia il three way
+handshake, e ritorna solo quando la connessione è stabilita o si è verificato
+un errore. Le possibili cause di errore sono molteplici (e brevemente
+riassunte sopra), in particolare le principali sono:
+
+\begin{enumerate}
+\item Se il client non riceve risposta al SYN l'errore restituito è
+ \texttt{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
+ di \texttt{connect}, un'altro dopo 6 secondi, un terzo dopo 24 secondi, se
+ dopo 75 secondi non ha ricevuto risposta viene ritornato l'errore. Linux
+ invece ripete l'emissione del SYN ad intervalli di 30 secondi per un numero
+ di volte che può essere stabilito dall'utente sia con una opportuna
+ \texttt{sysctl} che attraverso il filesystem \texttt{/proc} scrivendo il
+ valore voluto in \texttt{/proc/sys/net/ipv4/tcp_syn_retries}. Il valore di
+ default per la ripetizione dell'invio è di 5 volte, che comporta un timeout
+ dopo circa 180 secondi.
+%
+% Le informazioni su tutte le opzioni settabili via /proc stanno in
+% linux/Documentation/networking/ip-sysctl.txt
+%
+\item Se il client riceve come risposta al SYN un RST significa che non c'è
+ nessun programma in ascolto per la connessione sulla porta specificata (il
+ che vuol dire probablmente che o si è sbagliato il numero della porta o che
+ non è stato avviato il server), questo è un errore fatale e la funzione
+ ritorna non appena il RST viene ricevuto riportando un errore
+ \texttt{ECONNREFUSED}.
+
+ Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
+ dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
+ quando arriva un SYN per una porta che non ha nessun server in ascolto,
+ quando il TCP abortisce una connessione in corso, quandi TCP riceve un
+ segmento per una connessione che non esiste.
+
+\item Il SYN del client provoca l'emissione di un messaggio ICMP di
+ destinazione non raggiungibile
+
+\end{enumerate}
+
\subsection{La funzione \texttt{bind}}
\label{sec:TCPel_func_bind}
+
+
\subsection{La funzione \texttt{listen}}
\label{sec:TCPel_func_listen}
\label{sec:TCPel_func_accept}
-\subsection{Le porte}
-
-
+\section{Una semplice implementazione del servizio \textt{echo} su TCP}
+\label{sec:TCPel_echo_example}
projects / gapil.git / blobdiff