[gapil.git] / elemtcp.tex

\chapter{Socket TCP elementari}
\label{cha:elem_TCP_sock}

In questo capitolo inizieremo ad approndire la conoscenza dei socket TCP,
tratteremo qui dunque il funzionamento delle varie funzioni che si sono usate
nei due esempi elementari forniti in precedenza (vedi \ref{sec:net_cli_sample}
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 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}

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.

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.

\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:

\begin{itemize}
\item Il server deve essere preparato per accettare le connessioni in arrivo;
  il procedimento si chiama \textsl{apertura passiva} del socket (da
  \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.
  
\item Il client richiede l'inizio della connessione usando la funzione
  \texttt{connect}, attraverso un procedimento che viene chiamato
  \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
  \texttt{connect} blocca il processo e causa l'invio da parte del client di
  un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
    elementare di dati trasmessa dal protocollo TCP al livello superiore;
    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
    \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
    come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a
    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.
  
\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
  ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
  \texttt{ACK} e sono settati.
  
\item una volta che il client ha ricevuto l'acknowledge dal server la funzione
  \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
  \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
  quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
  è 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.

% Una analogia citata da R. Stevens per la connessione TCP è quella con il
% sistema del telefono. La funzione \texttt{socket} può essere considerata
% l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al
% dire alle altre persone qual'è il proprio numero di telefono perché possano
% chiamare. La funzione \texttt{listen} è accendere il campanello del telefono
% per sentire le chiamate in arrivo.  La funzione \texttt{connect} richiede di
% conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è
% quando si risponde al telefono.

\begin{figure}[htb]
  \centering
  
  \caption{Il \textit{three way handshake} del TCP}
  \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.

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
\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
è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso
varrà anche (vedi \nfig) per l'acknowledgement di un FIN.

\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:

\begin{itemize}
\item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
  opzione ciascun capo della connessione annuncia all'altro il massimo
  ammontare di dati che vorrebbe accettare per ciascun segmento nella
  connesione corrente. È possibile leggere e scrivere questo valore attraverso
  l'opzione del socket \texttt{TCP\_MAXSEG}.
  
\item \textit{window scale option} come spiegato in \ref{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'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
  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
  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 shiftare a sinistra il valore
  della finestra annunciata).

\item \textit{timestamp option} è anche questa una nuova opzione necessaria
  per le connessioni ad alta velocità per evitare possibili corruzioni di dati
  dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
  la precedente.

\end{itemize}

La MSS è generalmente supportata da quasi tutte le implementazioni del
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. In ogni caso linux supporta pienamente entrambe le opzioni.

\subsection{La terminazione della connessione}
\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:

\begin{enumerate}
\item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
  l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da
  \textit{active close}). Questo comporta l'emissione di un segmento FIN, che
  significa che si è finito con l'invio dei dati sulla connessione.
  
\item L'altro capo della connessione riceve il FIN ed esegue la
  \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
  tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
  viene passato al processo che ha aperto il socket come un end of file sulla
  lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
  ricevuto), dato che il ricevimento di un FIN significa che non si
  riceveranno altri dati sulla connessione.

\item Dopo un certo tempo anche il secondo processo chiamerà la funzione
  \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
  FIN. 
  
\item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
  con un ACK.
\end{enumerate}


Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
sequenza di scambio dei segmenti che stabilisce la connessione.

\begin{figure}[htb]
  \centering
  
  \caption{Il \textit{three way handshake} del TCP}
  \label{fig:TCPel_TWH}
\end{figure}

Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
l'ACK riporterà un \textit{acknowledge number} incrementato di uno. 

Si noti che nella sequenza di chiusura fra i passi 2 e 3 è in teoria possibile
che si mantenga un flusso di dati dal capo della connessione che sta eseguendo
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
\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
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
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}

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
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}

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}

\subsection{La funzione \texttt{accept}}
\label{sec:TCPel_func_accept}


\section{Una semplice implementazione del servizio \textt{echo} su TCP}
\label{sec:TCPel_echo_example}