-\chapter{Socket TCP elementari}
-\label{cha:elem_TCP_sock}
+%% elemtcp.tex
+%%
+%% Copyright (C) 2000-2003 Simone Piccardi. Permission is granted to
+%% copy, distribute and/or modify this document under the terms of the GNU Free
+%% Documentation License, Version 1.1 or any later version published by the
+%% Free Software Foundation; with the Invariant Sections being "Prefazione",
+%% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
+%% license is included in the section entitled "GNU Free Documentation
+%% License".
+%%
+\chapter{Socket TCP}
+\label{cha:TCP_socket}
In questo capitolo iniziamo ad approfondire 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
-\secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}), previa una
-descrizione delle principali caratteristiche del funzionamento di una
-connessione TCP.
+iniziando con una descrizione delle principali caratteristiche del
+funzionamento di una connessione TCP. Tratteremo poi le varie funzioni che
+servono alla creazione di una connessione fra un server elementare ed il suo
+client, fornendo poi alcuni esempi di applicazione elementare.
+
\section{Il funzionamento di una connessione TCP}
-\label{sec:TCPel_connession}
+\label{sec:TCP_connession}
-Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
-utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
-del TCP; la conoscenza del funzionamento del protocollo è infatti essenziale
-per capire il modello di programmazione ed il funzionamento delle API.
+Prima di entrare nei dettagli delle singole funzioni usate nelle applicazioni
+che utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del
+funzionamento del protocollo, poiché questa conoscenza è essenziale per
+comprendere il comportamento di dette funzioni per questo tipo di socket, ed
+il relativo modello di programmazione.
-In particolare ci concentreremo sulle modalità con le quali il protocollo dà
-inizio e conclude una connessione; faremo inoltre 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 \cmd{netstat}.
+Si ricordi che il protocollo TCP serve a creare degli \textit{stream socket},
+cioè una forma di canale di comunicazione che stabilisce una connessione
+stabile fra due stazioni, in modo che queste possano scambiarsi dei dati. In
+questa sezione ci concentreremo sulle modalità con le quali il protocollo dà
+inizio e conclude una connessione e faremo inoltre un breve accenno al
+significato di alcuni dei vari \textsl{stati} ad essa associati.
\subsection{La creazione della connessione: il \textit{three way handshake}}
-\label{sec:TCPel_conn_cre}
+\label{sec:TCP_conn_cre}
Il processo che porta a creare una connessione TCP è chiamato \textit{three
- way handshake}; la successione tipica degli eventi (la stessa che si
-verifica utilizzando il codice dei due precedenti esempi elementari
-\figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
-creazione di una connessione è la seguente:
+ way handshake}; la successione tipica degli eventi (e dei
+\textsl{segmenti}\footnote{Si ricordi che il segmento è l'unità elementare di
+ dati trasmessa dal protocollo TCP al livello successivo; tutti i segmenti
+ hanno un header che contiene le informazioni che servono allo \textit{stack
+ TCP} (così viene di solito chiamata la parte del kernel che implementa il
+ protocollo) per realizzare la comunicazione, fra questi dati ci sono una
+ serie di flag usati per gestire la connessione, come SYN, ACK, URG, FIN,
+ alcuni di essi, come SYN (che sta per \textit{syncronize}) corrispondono a
+ funzioni particolari del protocollo e danno il nome al segmento, (per
+ maggiori dettagli vedere \secref{sec:tcp_protocol}).} di dati che vengono
+scambiati) che porta alla creazione di una connessione è la seguente:
\begin{enumerate}
\item Il server deve essere preparato per accettare le connessioni in arrivo;
il procedimento si chiama \textsl{apertura passiva} del socket (in inglese
- \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni
+ \textit{passive open}). Questo viene fatto chiamando la sequenza di funzioni
\func{socket}, \func{bind} e \func{listen}. Completata l'apertura passiva il
server chiama la funzione \func{accept} e il processo si blocca in attesa di
connessioni.
\func{connect}, attraverso un procedimento che viene chiamato
\textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
\func{connect} blocca il processo e causa l'invio da parte del client di un
- segmento SYN\footnote{Si ricordi che il segmento è l'unità elementare di
- dati trasmessa dal protocollo TCP al livello 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 SYN, ACK,
- URG, FIN, alcuni di essi, come SYN (che sta per \textit{syncronize})
- corrispondono a funzioni particolari del protocollo e danno il nome al
- segmento, (per maggiori dettagli vedere \capref{cha:tcp_protocol})}, in
- sostanza viene inviato al server un pacchetto IP che contiene solo gli
- header IP e TCP (con il numero di sequenza iniziale e il flag SYN) e le
- opzioni di TCP.
+ segmento SYN, in sostanza viene inviato al server un pacchetto IP che
+ contiene solo gli header IP e TCP (con il numero di sequenza iniziale e il
+ flag SYN) e le opzioni di TCP.
\item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del
client, inoltre anche il server deve inviare il suo SYN al client (e
trasmettere il suo numero di sequenza iniziale) questo viene fatto
- ritrasmettendo un singolo segmento in cui entrambi i flag SYN ACK e sono
- settati.
+ ritrasmettendo un singolo segmento in cui sono impostati entrambi i flag SYN
+ e ACK.
\item una volta che il client ha ricevuto l'acknowledge dal server la funzione
\func{connect} ritorna, l'ultimo passo è dare dare il ricevuto del SYN del
\end{enumerate}
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.
+realizzarlo devono essere scambiati tre segmenti. In \figref{fig:TCP_TWH}
+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
\begin{figure}[htb]
\centering
- \includegraphics[width=10cm]{img/three_way_handshake.eps}
- \caption{Il \textit{three way handshake} del TCP}
- \label{fig:TCPel_TWH}
+ \includegraphics[width=10cm]{img/three_way_handshake}
+ \caption{Il \textit{three way handshake} del TCP.}
+ \label{fig:TCP_TWH}
\end{figure}
Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche
-riportati in \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.
+riportati in \figref{fig:TCP_TWH}): per gestire una connessione affidabile
+infatti il protocollo TCP prevede nell'header la presenza di un numero a 32
+bit (chiamato appunto \textit{sequence number}) che identifica a quale byte
+nella sequenza del flusso corrisponde il primo byte della sezione dati
+contenuta nel segmento.
Il numero di sequenza di ciascun segmento viene calcolato a partire da 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
+ciascun segmento viene effettuato dall'altro capo della connessione impostando
il flag 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.
+varrà anche (vedi \figref{fig:TCP_close}) per l'acknowledgement di un FIN.
\subsection{Le opzioni TCP.}
-\label{sec:TCPel_TCP_opt}
+\label{sec:TCP_TCP_opt}
Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP
(le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i
questa opzione ciascun capo della connessione annuncia all'altro il massimo
ammontare di dati che vorrebbe accettare per ciascun segmento nella
connessione corrente. È possibile leggere e scrivere questo valore
- attraverso l'opzione del socket \macro{TCP\_MAXSEG}.
+ attraverso l'opzione del socket \const{TCP\_MAXSEG}.
-\item \textit{window scale option}; come spiegato in \capref{cha:tcp_protocol}
+\item \textit{window scale option}, %come spiegato in \secref{sec:tcp_protocol}
il protocollo TCP implementa il controllo di flusso attraverso una
\textsl{finestra annunciata} (\textit{advertized window}) con la quale
ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
memoria per i dati. Questo è un numero a 16 bit dell'header, che così può
- indicare un massimo di 65535 bytes (anche se Linux usa come massimo 32767
- per evitare problemi con alcuni stack bacati che usano l'aritmetica con
- segno per implementare lo stack TCP); ma alcuni tipi di connessione come
- quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
+ indicare un massimo di 65535 byte;\footnote{ Linux usa come massimo 32767
+ per evitare problemi con alcune implementazioni che usano l'aritmetica con
+ segno per implementare lo stack TCP.} ma alcuni tipi di connessione come
+ quelle ad alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi
ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
più grande per poter ottenere il massimo dalla trasmissione, per questo
esiste questa opzione che indica un fattore di scala da applicare al valore
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
+ suo SYN di risposta dell'apertura della connessione.} per la connessione
+ corrente (espresso come numero di bit cui spostare a sinistra il valore
della finestra annunciata inserito nel pacchetto).
\item \textit{timestamp option}, è anche questa una nuova opzione necessaria
\end{itemize}
La MSS è generalmente supportata da quasi tutte le implementazioni del
-protocollo, le ultime due opzioni (trattate nell'RFC~1323) sono meno comuni;
+protocollo, le ultime due opzioni (trattate
+nell'\href{http://www.ietf.org/rfc/rfc1323.txt}{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}
+\label{sec:TCP_conn_term}
-Mentre per creare una connessione occorre un interscambio di tre segmenti, la
-procedura di chiusura ne richiede quattro; ancora una volta si può fare
-riferimento al codice degli esempi \figref{fig:net_cli_code} e
-\figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
-seguente:
+Mentre per la creazione di una connessione occorre un interscambio di tre
+segmenti, la procedura di chiusura ne richiede normalmente quattro. In questo
+caso la successione degli eventi è la seguente:
\begin{enumerate}
\item Un processo ad uno dei due capi chiama la funzione \func{close}, dando
l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o
\textit{active close}). Questo comporta l'emissione di un segmento FIN, che
- significa che si è finito con l'invio dei dati sulla connessione.
+ serve ad indicare 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} (o \textit{passive close}); al FIN, come ad ogni
- altro pacchetto, viene risposto con un ACK. Inoltre il ricevimento del FIN
+\item L'altro capo della connessione riceve il FIN e dovrà eseguire la
+ \textsl{chiusura passiva} (o \textit{passive close}). Al FIN, come ad ogni
+ altro pacchetto, viene risposto con un ACK, inoltre il ricevimento del FIN
viene segnalato al processo che ha aperto il socket (dopo che ogni altro
eventuale dato rimasto in coda è stato ricevuto) come un end-of-file sulla
- lettura, questo perché il ricevimento di un FIN significa che non si
+ lettura: questo perché 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
- \func{close} sul proprio socket, causando l'emissione di un altro segmento
- FIN.
+
+\item Una volta rilevata l'end-of-file anche il secondo processo chiamerà la
+ funzione \func{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.
giacché in alcune situazioni il FIN del passo 1) è inviato insieme a dei dati.
Inoltre è possibile che i segmenti inviati nei passi 2 e 3 dal capo che
effettua la chiusura passiva, siano accorpati in un singolo segmento. In
-\nfig\ si è rappresentato graficamente lo sequenza di scambio dei segmenti che
-stabilisce la connessione.
+\figref{fig:TCP_close} si è rappresentato graficamente lo sequenza di
+scambio dei segmenti che conclude la connessione.
\begin{figure}[htb]
\centering
- \includegraphics[width=10cm]{img/tcp_close.eps}
- \caption{La chiusura di una connessione TCP}
- \label{fig:TCPel_close}
+ \includegraphics[width=10cm]{img/tcp_close}
+ \caption{La chiusura di una connessione TCP.}
+ \label{fig:TCP_close}
\end{figure}
Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
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 deve ancora
-eseguire la chiusura passiva a quello che sta eseguendo la chiusura attiva.
-Nella sequenza indicata i dati verrebbero persi, dato che si è chiuso il
-socket dal lato che esegue la chiusura attiva; esistono tuttavia situazioni in
-cui si vuole poter sfuttare questa possibilità, usando una procedura che è
-chiamata \textit{half-close}; torneremo su questo aspetto e su come
-utilizzarlo più avanti, quando parleremo della funzione \func{shutdown}.
+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
+deve ancora eseguire la chiusura passiva a quello che sta eseguendo la
+chiusura attiva. Nella sequenza indicata i dati verrebbero persi, dato che si
+è chiuso il socket dal lato che esegue la chiusura attiva; esistono tuttavia
+situazioni in cui si vuole poter sfruttare questa possibilità, usando una
+procedura che è chiamata \textit{half-close}; torneremo su questo aspetto e su
+come utilizzarlo in \secref{xxx_shutdown}, quando parleremo della funzione
+\func{shutdown}.
La emissione del FIN avviene quando il socket viene chiuso, questo però non
-avviene solo per la chiamata della funzione \func{close} (come in
-\figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
-in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
-viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
+avviene solo per la chiamata esplicita della funzione \func{close}, ma anche
+alla terminazione di un processo, quando tutti i file vengono chiusi. Questo
+comporta ad esempio che se un processo viene terminato da un segnale tutte le
+connessioni aperte verranno chiuse.
-Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
-più avanti in \secref{sec:TCPsimp_echo}) sia stato il client ad eseguire la
-chiusura attiva, nella realtà questa può essere eseguita da uno qualunque dei
-due capi della comunicazione (come in fatto in precedenza nell'esempio di
-\figref{fig:net_serv_code}), e anche se il caso più comune resta quello del
-client, ci sono alcuni servizi, il principale dei quali è l'HTTP, per i
-quali è il server ad effettuare la chiusura attiva.
+Infine occorre sottolineare che, benché nella figura (e nell'esempio che
+vedremo più avanti in \secref{sec:TCP_echo}) sia stato il client ad eseguire
+la chiusura attiva, nella realtà questa può essere eseguita da uno qualunque
+dei due capi della comunicazione (come nell'esempio di
+\figref{fig:TCP_daytime_iter_server_code}), e anche se il caso più comune
+resta quello del client, ci sono alcuni servizi, il principale dei quali è
+l'HTTP, per i quali è il server ad effettuare la chiusura attiva.
\subsection{Un esempio di connessione}
-\label{sec:TCPel_conn_dia}
-
-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 un socket ed un insieme
-di regole per le transizioni da uno stato all'altro basate sullo stato
-corrente e sul tipo di segmento ricevuto; i nomi degli stati sono gli stessi
-che vengono riportati del comando \cmd{netstat} nel campo \textit{State}.
-
-Una descrizione completa del funzionamento del protocollo va al di là degli
-obiettivi di questo libro; un approfondimento sugli aspetti principali si
-trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il
-miglior riferimento resta (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).
+\label{sec:TCP_conn_dia}
+
+Come abbiamo visto le operazioni del TCP nella creazione e conclusione di una
+connessione sono piuttosto complesse, ed abbiamo esaminato soltanto quelle
+relative ad un andamento normale. In \secref{sec:TCP_states} vedremo con
+maggiori dettagli che una connessione può assumere vari stati, che ne
+caratterizzano il funzionamento, e che sono quelli che vengono riportati dal
+comando \cmd{netstat}, per ciascun socket TCP aperto, nel campo
+\textit{State}.
+
+Non possiamo affrontare qui una descrizione completa del funzionamento del
+protocollo; un approfondimento sugli aspetti principali si trova in
+\secref{sec:tcp_protocol}, ma per una trattazione completa il miglior
+riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un
+semplice esempio di connessione e le transizioni che avvengono nei due casi
+appena citati (creazione e terminazione della connessione).
In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una
applicazione esegue una apertura attiva il TCP emette un SYN e lo stato
stato \texttt{LISTEN} in cui vengono accettate le connessioni.
Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
-chiama la \texttt{close} prima di aver ricevuto un end of file (chiusura
-attiva) la transizione è verso lo stato \texttt{FIN\_WAIT\_1}; se invece
-l'applicazione riceve un FIN nello stato \texttt{ESTABLISHED} (chiusura
-passiva) la transizione è verso lo stato \texttt{CLOSE\_WAIT}.
+chiama la funzione \texttt{close} prima di aver ricevuto un
+\textit{end-of-file} (chiusura attiva) la transizione è verso lo stato
+\texttt{FIN\_WAIT\_1}; se invece l'applicazione riceve un FIN nello stato
+\texttt{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato
+\texttt{CLOSE\_WAIT}.
-In \nfig\ è riportato lo schema dello scambio dei pacchetti che avviene per
-una un esempio di connessione, insieme ai vari stati che il protocollo viene
-ad assumere per i due lati, server e client.
+In \figref{fig:TCP_conn_example} è riportato lo schema dello scambio dei
+pacchetti che avviene per una un esempio di connessione, insieme ai vari stati
+che il protocollo viene ad assumere per i due lati, server e client.
\begin{figure}[htb]
\centering
- \includegraphics[width=9cm]{img/tcp_connection.eps}
- \caption{Schema dello scambio di pacchetti per un esempio di connessione}
- \label{fig:TPCel_conn_example}
+ \includegraphics[width=9cm]{img/tcp_connection}
+ \caption{Schema dello scambio di pacchetti per un esempio di connessione.}
+ \label{fig:TCP_conn_example}
\end{figure}
-La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
-valore tipico per IPv4 su ethernet) con Linux, il server risponde con lo
-stesso valore (ma potrebbe essere anche un valore diverso).
+La connessione viene iniziata dal client che annuncia un MSS di 1460, un
+valore tipico con Linux per IPv4 su Ethernet, il server risponde con lo stesso
+valore (ma potrebbe essere anche un valore diverso).
Una volta che la connessione è stabilita il client scrive al server una
richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
-1460 bytes annunciati dal server), quest'ultimo riceve la richiesta e
+1460 byte annunciati dal server), quest'ultimo riceve la richiesta e
restituisce una risposta (che di nuovo supponiamo stare in un singolo
segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
-risposta, questo viene chiamato \textit{piggybacking} ed avviene tutte le
-volte che che il server è sufficientemente veloce a costruire la risposta, in
+risposta: questo viene chiamato \textit{piggybacking} ed avviene tutte le
+volte che che il server è sufficientemente veloce a costruire la risposta; in
caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della
risposta.
Infine si ha lo scambio dei quattro segmenti che terminano la connessione
-secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo
-della connessione che esegue la chiusura attiva entra nello stato
-\texttt{TIME\_WAIT} su cui torneremo fra poco.
+secondo quanto visto in \secref{sec:TCP_conn_term}; si noti che il capo della
+connessione che esegue la chiusura attiva entra nello stato
+\texttt{TIME\_WAIT}, sul cui significato torneremo fra poco.
È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
e uno di risposta) il TCP necessiti di ulteriori otto segmenti, se invece si
dati rispondono meglio alle esigenze che devono essere affrontate.
\subsection{Lo stato \texttt{TIME\_WAIT}}
-\label{sec:TCPel_time_wait}
+\label{sec:TCP_time_wait}
-Come riportato da Stevens (FIXME citare) lo stato \texttt{TIME\_WAIT} è
+Come riportato da Stevens in \cite{UNP1} 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.
+comune trovare domande su come sia possibile evitare che un'applicazione resti
+in questo stato lasciando attiva una connessione ormai conclusa; la risposta è
+che non deve essere fatto, ed il motivo cercheremo di spiegarlo adesso.
-Come si è visto nell'esempio precedente (vedi \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
-(\textit{Maximum Segment Lifetime}).
+Come si è visto nell'esempio precedente (vedi \figref{fig:TCP_conn_example})
+\texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che
+esegue la chiusura attiva resta prima di passare alla chiusura definitiva
+della connessione. Il tempo in cui l'applicazione resta in questo stato deve
+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 \secref{sec:IP_xxx}), e viene decrementato
-ad 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 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'RFC~1122
-raccomanda 2 minuti, Linux usa 30 secondi), questo comporta una durata dello
-stato \texttt{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:
+IP (per maggiori dettagli vedi \secref{sec:IP_xxx}), e viene decrementato ad
+ogni passaggio da un router; quando si annulla il pacchetto viene scartato.
+Siccome il numero è ad 8 bit il numero massimo di ``\textsl{salti}'' è di 255,
+pertanto 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'\href{http://www.ietf.org/rfc/rfc1122.txt}{RFC~1122} raccomanda 2 minuti,
+Linux usa 30 secondi), questo comporta una durata dello stato
+\texttt{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{enumerate}
\item implementare in maniera affidabile la terminazione della connessione
in entrambe le direzioni.
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 ricevendo 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.
+Il primo dei due motivi precedenti si può capire tornando a
+\figref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza
+(quello del capo che ha eseguito la chiusura attiva) vanga perso, chi esegue
+la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per
+questo motivo chi esegue la chiusura attiva deve mantenere lo stato della
+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 \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.
+motivo un socket deve rimanere attivo nello stato \texttt{TIME\_WAIT} anche
+dopo l'invio dell'ultimo ACK, per potere essere in grado di gestirne
+l'eventuale ritrasmissione, in caso esso venga perduto.
-Il secondo motivo è più complesso da capire, e necessita di spiegare meglio
-gli scenari in cui accade che i pacchetti si possono perdere nella rete o
-restare intrappolati, per poi riemergere.
+Il secondo motivo è più complesso da capire, e necessita di una spiegazione
+degli scenari in cui può accadere che i pacchetti TCP si possano perdere nella
+rete o restare intrappolati, per poi riemergere in un secondo tempo.
Il caso più comune in cui questo avviene è quello di anomalie
nell'instradamento; può accadere cioè che un router smetta di funzionare o che
un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
cosiddetti \textit{routing loop}) in cui restano intrappolati i pacchetti.
-Se uno di questi pacchetti intrappolati è un segmento di TCP chi l'ha inviato,
-non ricevendo risposta, provvederà alla ritrasmissione e se nel frattempo sarà
-stata stabilita una strada alternativa il pacchetto ritrasmesso giungerà a
-destinazione.
+Se uno di questi pacchetti intrappolati è un segmento TCP, chi l'ha inviato,
+non ricevendo un ACK in risposta, provvederà alla ritrasmissione e se nel
+frattempo sarà stata stabilita una strada alternativa il pacchetto ritrasmesso
+giungerà a destinazione.
Ma se dopo un po' di tempo (che non supera il limite dell'MSL, dato che
-altrimenti verrebbe ecceduto il TTL) l'anomalia viene a cessare il circolo di
+altrimenti verrebbe ecceduto il TTL) l'anomalia viene a cessare, il circolo di
instradamento 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.
+connessione fra l'IP \texttt{195.110.112.236} porta 1550 e l'IP
+\texttt{192.84.145.100} porta 22 (affronteremo il significato delle porte
+nella prossima sezione), che questa venga chiusa e che poco dopo si
+ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte
+(quella che viene detta, essendo gli stessi porte e numeri IP, una nuova
+\textsl{incarnazione} della connessione precedente); in questo caso ci si
+potrebbe trovare con dei pacchetti duplicati relativi alla precedente
+connessione che riappaiono nella nuova.
Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
-creata, per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
+creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere
-sicuri che lo stesso avvenga le risposte nella direzione opposta.
+sicuri che lo stesso avvenga per le risposte nella direzione opposta.
-In questo modo il TCP si assicura che quando una viene creata una nuova
-connessione tutti gli eventuali segmenti residui di una precedente connessione
-che possono causare disturbi sono stati eliminati dalla rete.
+In questo modo, prima che venga creata una nuova connessione, il protocollo
+TCP si assicura che tutti gli eventuali segmenti residui di una precedente
+connessione, che potrebbero causare disturbi, siano stati eliminati dalla
+rete.
\subsection{I numeri di porta}
-\label{sec:TCPel_port_num}
+\label{sec:TCP_port_num}
-In un ambiente multitasking in un dato momento più processi possono dover
-usare sia UDP che TCP, e ci devono poter essere più connessioni in
-contemporanea. Per poter tenere distinte le diverse connessioni entrambi i
-protocolli usano i \textsl{numeri di porta}, che fanno parte, come si può
-vedere in \secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle
-strutture degli indirizzi del socket.
+In un ambiente multitasking in un dato momento più processi devono poter usare
+sia UDP che TCP, e ci devono poter essere più connessioni in contemporanea.
+Per poter tenere distinte le diverse connessioni entrambi i protocolli usano i
+\textsl{numeri di porta}, che fanno parte, come si può vedere in
+\secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle strutture
+degli indirizzi del socket.
Quando un client contatta un server deve poter identificare con quale dei vari
possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
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.
+servizio 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
usate solo per la durata della connessione, e l'unico requisito che deve
essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
-La lista delle porte conosciute è definita dall'RFC~1700 che contiene l'elenco
-delle porte assegnate dalla IANA (\textit{Internet Assigned Number Authority})
-ma l'elenco viene costantemente aggiornato e pubblicato all'indirizzo
-\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}, inoltre il
-file \file{/etc/services} contiene un analogo elenco, con la corrispondenza
-fra i numeri di porta ed il nome simbolico del servizio. I numeri sono divisi
-in tre intervalli:
+La lista delle porte conosciute è definita
+dall'\href{http://www.ietf.org/rfc/rfc1700.txt}{RFC~1700} che contiene
+l'elenco delle porte assegnate dalla IANA (la \textit{Internet Assigned Number
+ Authority}) ma l'elenco viene costantemente aggiornato e pubblicato su
+internet (una versione aggiornata si può trovare all'indirizzo
+\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}); inoltre
+in un sistema unix-like un analogo elenco viene mantenuto nel file
+\file{/etc/services}, con la corrispondenza fra i vari numeri di porta ed il
+nome simbolico del servizio. I numeri sono divisi in tre intervalli:
\begin{enumerate}
\item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono
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
+ è 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 i candidati naturali ad essere usate come porte effimere.
\end{enumerate}
-In realtà rispetto a quanto indicato nell'RFC~1700 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
-intervalli possibili viene fatta dinamicamente a seconda della memoria a
-disposizione del kernel per gestire le relative tabelle.
+In realtà rispetto a quanto indicato
+nell'\href{http://www.ietf.org/rfc/rfc1700.txt}{RFC~1700} i vari sistemi hanno
+fatto scelte diverse per le porte effimere, in particolare in
+\figref{fig:TCP_port_alloc} sono riportate quelle di BSD e Linux. Nel caso di
+Linux poi la scelta fra i due intervalli possibili viene fatta dinamicamente a
+seconda della memoria a disposizione del kernel per gestire le relative
+tabelle.
\begin{figure}[!htb]
\centering
- \includegraphics[width=10cm]{img/port_alloc.eps}
- \caption{Allocazione dei numeri di porta}
- \label{fig:TCPel_port_alloc}
+ \includegraphics[width=15cm]{img/port_alloc}
+ \caption{Allocazione dei numeri di porta.}
+ \label{fig:TCP_port_alloc}
\end{figure}
-I sistemi unix hanno inoltre il concetto di \textsl{porte riservate} (che
+I sistemi Unix hanno inoltre il concetto di \textsl{porte riservate} (che
corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
porte conosciute). La loro caratteristica è che possono essere assegnate a un
-socket solo da un processo con i privilegi di root, per far si che solo
-l'amministratore possa allocare queste porte per far partire i relativi
+socket solo da un processo con i privilegi di amministratore, per far si che
+solo l'amministratore possa allocare queste porte per far partire i relativi
servizi.
-Si tenga conto poi che ci sono alcuni client (in particolare \cmd{rsh} e
-\cmd{rlogin}) che richiedono una connessione su una porta riservata anche
-dal lato client come parte dell'autenticazione. Questo viene fatto tramite la
-funzione \func{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, che scriveremo usando una notazione del
-tipo (195.110.112.152:22, 192.84.146.100:20100), identifica univocamente una
-connessione su internet. Questo concetto viene di solito esteso anche a UDP,
-benché in questo caso non abbia senso parlare di connessione. L'utilizzo del
-programma \cmd{netstat} permette di visualizzare queste informazioni nei campi
-\textit{Local Address} e \textit{Foreing Address}.
+Si tenga conto poi che ci sono alcuni client, in particolare \cmd{rsh} e
+\cmd{rlogin}, che richiedono una connessione su una porta riservata anche dal
+lato client come parte dell'autenticazione, contando appunto sul fatto che
+solo l'amministratore può usare queste porte. Data l'assoluta inconsistenza in
+termini di sicurezza di un tale metodo, al giorno d'oggi esso è in completo
+disuso.
+
+Data una connessione TCP si suole chiamare \textit{socket pair}\footnote{da
+ non confondere con la coppia di socket della omonima funzione
+ \func{socketpair} che fanno riferimento ad una coppia di socket sulla stessa
+ macchina, non ai capi di una connessione TCP.} la combinazione dei quattro
+numeri che definiscono i due capi della connessione e cioè l'indirizzo IP
+locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota.
+Questa combinazione, che scriveremo usando una notazione del tipo
+(\texttt{195.110.112.152:22}, \texttt{192.84.146.100:20100}), identifica
+univocamente una connessione su internet. Questo concetto viene di solito
+esteso anche a UDP, benché in questo caso non abbia senso parlare di
+connessione. L'utilizzo del programma \cmd{netstat} permette di visualizzare
+queste informazioni nei campi \textit{Local Address} e \textit{Foreing
+ Address}.
\subsection{Le porte ed il modello client/server}
-\label{sec:TCPel_port_cliserv}
+\label{sec:TCP_port_cliserv}
Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
-che fare con un'applicazione client/server (come quella che scriveremo in
-\secref{sec:TCPel_cunc_serv}) esamineremo cosa accade con le connessioni nel
-caso di un server TCP che deve gestire connessioni multiple.
+che fare con un'applicazione client/server (come quelle che descriveremo in
+\secref{sec:TCP_daytime_application} e \secref{sec:TCP_echo_application})
+esamineremo cosa accade con le connessioni nel caso di un server TCP che deve
+gestire connessioni multiple.
-Se eseguiamo un \cmd{netstat} su una macchina di prova (che supponiamo avere
-indirizzo 195.110.112.152) potremo avere un risultato del tipo:
+Se eseguiamo un \cmd{netstat} su una macchina di prova (il cui indirizzo sia
+\texttt{195.110.112.152}) potremo avere un risultato del tipo:
\begin{verbatim}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
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 e attivi un server ssh, un server di posta e un DNS per il
+essendo presenti e attivi un server SSH, un server di posta e un DNS per il
caching locale.
-Questo ci mostra ad esempio che il server ssh ha compiuto un'apertura passiva
-mettendosi in ascolto sulla porta 22 riservata a questo servizio e che si è
+Questo ci mostra ad esempio che il server SSH ha compiuto un'apertura passiva,
+mettendosi in ascolto sulla porta 22 riservata a questo servizio, e che si è
posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
-associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
-equivalente all'asterisco utilizzato per il numero di porta ed indica il
-valore generico, e corrisponde al valore \macro{INADDR\_ANY} definito in
-\file{arpa/inet.h}.
-
-Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
-specificati; in questo caso la \textit{socket pair} associata al socket può
-essere indicata come (*:22, *:*), usando l'asterisco anche per gli indirizzi
-come carattere di \textit{wildchard}.
-
-In genere avendo le macchine associato un solo IP ci si può chiedere che senso
-abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
-anche macchine che hanno più di un indirizzo IP (il cosiddetto
-\textit{multihoming}) in questo modo si possono accettare connessioni
-indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
-con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
-solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
-caso è fatta accettando solo connessioni che arrivino sull'interfaccia di
-loopback.
-
-Una volta che ci si vorrà collegare a questa macchina da un'altra posta
-all'indirizzo 192.84.146.100 si potrà lanciare un client \cmd{ssh} per
-creare una connessione verso la precedente, e il kernel assocerà al suddetto
-una porta effimera che per esempio potrà essere la 21100, la connessione
-allora sarà espressa dalla socket pair (192.84.146.100:21100,
-195.110.112.152.22).
+associati alle interfacce locali. La notazione \texttt{0.0.0.0} usata da
+\cmd{netstat} è equivalente all'asterisco utilizzato per il numero di porta,
+indica il valore generico, e corrisponde al valore \const{INADDR\_ANY}
+definito in \file{arpa/inet.h} (vedi \ref{tab:TCP_ipv4_addr}).
+
+Inoltre si noti come la porta e l'indirizzo di ogni eventuale connessione
+esterna non sono specificati; in questo caso la \textit{socket pair} associata
+al socket potrebbe essere indicata come (\texttt{*:22}, \texttt{*:*}), usando
+anche per gli indirizzi l'asterisco come carattere che indica il valore
+generico.
+
+Dato che in genere una macchina è associata ad un solo indirizzo IP, ci si può
+chiedere che senso abbia l'utilizzo dell'indirizzo generico per specificare
+l'indirizzo locale; ma a parte il caso di macchine che hanno più di un
+indirizzo IP (il cosiddetto \textit{multihoming}) esiste sempre anche
+l'indirizzo di loopback, per cui con l'uso dell'indirizzo generico si possono
+accettare connessioni indirizzate verso uno qualunque degli indirizzi IP
+presenti. Ma, come si può vedere nell'esempio con il DNS che è in ascolto
+sulla porta 53, è possibile anche restringere l'accesso ad uno specifico
+indirizzo, cosa che nel caso è fatta accettando solo connessioni che arrivino
+sull'interfaccia di loopback.
+
+Una volta che ci si vorrà collegare a questa macchina da un'altra, per esempio
+quella con l'indirizzo \texttt{192.84.146.100}, si dovrà lanciare su
+quest'ultima un client \cmd{ssh} per creare una connessione, e il kernel gli
+assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà
+espressa dalla socket pair (\texttt{192.84.146.100:21100},
+\texttt{195.110.112.152:22}).
Alla ricezione della richiesta dal client il server creerà un processo figlio
per gestire la connessione, se a questo punto eseguiamo nuovamente il
-programma netstat otterremo come risultato:
+programma \cmd{netstat} otteniamo come risultato:
\begin{verbatim}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
\end{verbatim}
Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
-c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che anch'esso utilizza
+c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che utilizza anch'esso
la porta 22, ed ha specificato l'indirizzo locale, questo è il socket con cui
il processo figlio gestisce la connessione mentre il padre resta in ascolto
sul socket originale.
-Se a questo punto lanciamo un'altra volta il client ssh per una seconda
-connessione quello che otterremo usando netstat sarà qualcosa del genere:
+Se a questo punto lanciamo un'altra volta il client \cmd{ssh} per una seconda
+connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
+genere:
\begin{verbatim}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
\end{verbatim}
-cioè il client effettuerà la connessione usando un'altra porta effimera, con
+cioè il client effettuerà la connessione usando un'altra porta effimera: con
questa sarà aperta la connessione, ed il server creerà un'altro processo
-figlio sarà creato per gestirla.
+figlio per gestirla.
-Tutto ciò mostra come TCP, per poter gestire le connessioni con un server
+Tutto ciò mostra come il TCP, per poter gestire le connessioni con un server
concorrente, non può suddividere i pacchetti solo sulla base della porta di
destinazione, ma deve usare tutta l'informazione contenuta nella socket pair,
compresa la porta dell'indirizzo remoto. E se andassimo a vedere quali sono i
-processi a cui fanno riferimento i vari socket vedremmo che i pacchetti che
-arrivano dalla porta remota 21100 vanno al primo figlio e quelli che arrivano
-alla porta 21101 al secondo.
+processi\footnote{ad esempio con il comando \cmd{fuser}, o con \cmd{lsof}.} a
+cui fanno riferimento i vari socket vedremmo che i pacchetti che arrivano
+dalla porta remota 21100 vanno al primo figlio e quelli che arrivano alla
+porta 21101 al secondo.
-\section{Le funzioni dei socket TCP}
-\label{sec:TCPel_functions}
+\section{Le funzioni di base per la gestione dei socket}
+\label{sec:TCP_functions}
-In questa sezione descriveremo in dettaglio le varie funzioni necessarie per
-l'uso dei socket TCP già citate in precedenza (e utilizzate nei due esempi
-\secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}) con l'eccezione
-della funzione \func{socket} che è già stata esaminata in dettaglio in
-\secref{sec:sock_socket}.
-
-In \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 \capref{cha:network} si assume che sia il
-client ad effettuare delle richieste a cui il server risponde, il client
-notifica poi di avere concluso inviando un end-of-file a cui il server
-risponderà anche lui chiudendo la connessione per aspettarne una nuova.
-
-\begin{figure}[!htb]
- \centering
-
- \caption{Struttura delle funzioni dei socket per una semplice applicazione
- client/server su TCP.}
- \label{fig:TCPel_cliserv_func}
-\end{figure}
-
-Useremo questo schema anche per l'esempio di reimplementazione del servizio
-\texttt{daytime} che illustreremo in \secref{sec:TCPel_cunc_serv}.
+In questa sezione descriveremo in maggior dettaglio le varie funzioni che
+vengono usate per la gestione di base dei socket TCP, non torneremo però sulla
+funzione \func{socket}, che è già stata esaminata accuratamente nel capitolo
+precedente in \secref{sec:sock_socket}.
\subsection{La funzione \func{bind}}
-\label{sec:TCPel_func_bind}
+\label{sec:TCP_func_bind}
-La funzione \func{bind} assegna un indirizzo locale ad un socket. È usata
+La funzione \funcd{bind} assegna un indirizzo locale ad un socket. È usata
cioè per specificare la prima parte dalla socket pair. Viene usata sul lato
server per specificare la porta (e gli eventuali indirizzi locali) su cui poi
ci si porrà in ascolto. Il prototipo della funzione è il seguente:
\begin{prototype}{sys/socket.h}
{int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)}
- Il primo argomento è un file descriptor ottenuto da una precedente chiamata
- a \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
- l'indirizzo (locale) del socket e la dimensione della struttura che lo
- contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
-
- La funzione restituisce zero in caso di successo e -1 per un errore; in caso
- di errore la variabile \var{errno} viene settata secondo i seguenti
- codici di errore:
+ Assegna un indirizzo ad un socket.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore;
+ in caso di errore la variabile \var{errno} viene impostata secondo i
+ seguenti codici di errore:
\begin{errlist}
- \item \macro{EBADF} il file descriptor non è valido.
- \item \macro{EINVAL} il socket ha già un indirizzo assegnato.
- \item \macro{ENOTSOCK} il file descriptor non è associato ad un socket.
- \item \macro{EACCESS} si è cercato di usare una porta riservata senza
- sufficienti privilegi.
+ \item[\errcode{EBADF}] il file descriptor non è valido.
+ \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato.
+ \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
+ \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
+ sufficienti privilegi.
+ \item[\errcode{EADDRNOTAVAIL}] Il tipo di indirizzo specificato non è
+ disponibile.
+ \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
\end{errlist}
+ ed anche \errval{EFAULT} e per i socket di tipo \const{AF\_UNIX},
+ \errval{ENOTDIR}, \errval{ENOENT}, \errval{ENOMEM}, \errval{ELOOP},
+ \errval{ENOSR} e \errval{EROFS}.}
\end{prototype}
-Con il TCP la chiamata \func{bind} permette di specificare l'indirizzo, la
-porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
+Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
+\func{socket}, mentre il secondo e terzo argomento sono rispettivamente
+l'indirizzo (locale) del socket e la dimensione della struttura che lo
+contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
+
+Con i socket TCP la chiamata \func{bind} permette di specificare l'indirizzo,
+la porta, entrambi o nessuno dei due. In genere i server utilizzano una porta
nota che assegnano all'avvio, se questo non viene fatto è il kernel a
scegliere una porta effimera quando vengono eseguite la funzioni
\func{connect} o \func{listen}, ma se questo è normale per il client non lo è
In questo caso viene fatta assegnare dal kernel una porta effimera che poi
viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
demone che deve essere contattato dai client per ottenere la porta effimera
- su cui si trova il server} che in genere viene identificato dalla porta su
-cui risponde.
+ su cui si trova il server.} che in genere viene identificato dalla porta su
+cui risponde (l'elenco di queste porte, e dei relativi servizi, è in
+\file{/etc/services}).
Con \func{bind} si può assegnare un IP specifico ad un socket, purché questo
appartenga ad una interfaccia della macchina. Per un client TCP questo
socket, mentre per un server TCP questo restringerà l'accesso al socket solo
alle connessioni che arrivano verso tale indirizzo.
-Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
-kernel sceglie l'indirizzo di origine quando viene effettuata la connessione
-sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
-dalle regole di instradamento usate per raggiungere il server).
-Se un server non specifica il suo indirizzo locale il kernel userà come
-indirizzo di origine l'indirizzo di destinazione specificato dal SYN del
-client.
-
-Per specificare un indirizzo generico con IPv4 si usa il valore
-\macro{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
-è pari a zero, nell'esempio \figref{fig:net_serv_code} si è usata
-un'assegnazione immediata del tipo:
-
-\footnotesize
-\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
- serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
-\end{lstlisting}
-\normalsize
+Normalmente un client non specifica mai l'indirizzo di un socket, ed il kernel
+sceglie l'indirizzo di origine quando viene effettuata la connessione, sulla
+base dell'interfaccia usata per trasmettere i pacchetti, (che dipenderà dalle
+regole di instradamento usate per raggiungere il server). Se un server non
+specifica il suo indirizzo locale il kernel userà come indirizzo di origine
+l'indirizzo di destinazione specificato dal SYN del client.
+
+Per specificare un indirizzo generico, con IPv4 si usa il valore
+\const{INADDR\_ANY}, il cui valore, come accennato in
+\secref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
+\figref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione immediata
+del tipo: \includecodesnip{listati/serv_addr_sin_addr.c}
Si noti che si è usato \func{htonl} per assegnare il valore
-\macro{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
-inutile; ma dato che tutte le costanti \macro{INADDR\_} sono definite
-secondo l'ordinamento della macchina è buona norma usare sempre la funzione
-\macro{htonl}.
-
-L'esempio precedete funziona con IPv4 dato che l'indirizzo è rappresentabile
-anche con un intero a 32 bit; non si può usare lo stesso metodo con IPv6,
-in cui l'indirizzo è specificato come struttura, perché il linguaggio C non
-consente l'uso di una struttura costante come operando a destra in una
-assegnazione.
-
-Per questo nell'header \file{netinet/in.h} è definita una variabile
-\type{in6addr\_any} (dichiarata come \type{extern}, ed inizializzata dal
-sistema al valore \macro{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
-assegnazione del tipo:
-\footnotesize
-\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
- serv_add.sin6_addr = in6addr_any; /* connect from anywhere */
-\end{lstlisting}
-\normalsize
+\const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
+inutile. Si tenga presente comunque che tutte le costanti \val{INADDR\_}
+(riportate in \tabref{tab:TCP_ipv4_addr}) sono definite secondo
+l'\textit{endianess} della macchina, ed anche se esse possono essere
+invarianti rispetto all'ordinamento dei bit, è comunque buona norma usare
+sempre la funzione \func{htonl}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Costante} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{INADDR\_ANY} & Indirizzo generico (\texttt{0.0.0.0})\\
+ \const{INADDR\_BROADCAST}& Indirizzo di \textit{broadcast}.\\
+ \const{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback}
+ (\texttt{127.0.0.1}).\\
+ \const{INADDR\_NONE} & Indirizzo errato.\\
+ \hline
+ \end{tabular}
+ \caption{Costanti di definizione di alcuni indirizzi generici per IPv4.}
+ \label{tab:TCP_ipv4_addr}
+\end{table}
+
+L'esempio precedente funziona correttamente con IPv4 poiché che l'indirizzo è
+rappresentabile anche con un intero a 32 bit; non si può usare lo stesso
+metodo con IPv6, in cui l'indirizzo deve necessariamente essere specificato
+con una struttura, perché il linguaggio C non consente l'uso di una struttura
+costante come operando a destra in una assegnazione.
+
+Per questo motivo nell'header \file{netinet/in.h} è definita una variabile
+\const{in6addr\_any} (dichiarata come \direct{extern}, ed inizializzata dal
+sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
+assegnazione del tipo: \includecodesnip{listati/serv_addr_sin6_addr.c} in
+maniera analoga si può utilizzare la variabile \const{in6addr\_loopback} per
+indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata
+staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}.
+
\subsection{La funzione \func{connect}}
-\label{sec:TCPel_func_connect}
+\label{sec:TCP_func_connect}
-La funzione \func{connect} è usata da un client TCP per stabilire la
+La funzione \funcd{connect} è usata da un client TCP per stabilire la
connessione con un server TCP, il prototipo della funzione è il seguente:
\begin{prototype}{sys/socket.h}
{int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t addrlen)}
- Il primo argomento è un file descriptor ottenuto da una precedente chiamata
- a \func{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 \secref{sec:sock_sockaddr}.
-
- La funzione restituisce zero in caso di successo e -1 per un errore, in caso
- di errore la variabile \var{errno} viene settata secondo i seguenti
- codici di errore:
+ Stabilisce una connessione fra due socket.
+
+ \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+ errore, nel qual caso \var{errno} assumerà i valori:
\begin{errlist}
- \item \macro{EISCONN} il socket è già connesso.
- \item \macro{ECONNREFUSED} non c'è nessuno in ascolto sull'indirizzo remoto.
- \item \macro{ETIMEDOUT} si è avuto timeout durante il tentativo di
+ \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
+ remoto.
+ \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
connessione.
- \item \macro{ENETUNREACH} la rete non è raggiungibile.
- \item \macro{EADDRINUSE} l'indirizzo locale è in uso.
- \item \macro{EINPROGRESS} il socket è non bloccante e la connessione non
- può essere conclusa immediatamente.
- \item \macro{EALREADY} il socket è non bloccante e un tentativo precedente
- di connessione non si è ancora concluso.
- \item \macro{EAGAIN} non ci sono più porte locali libere.
- \item \macro{EAFNOSUPPORT} l'indirizzo non ha una famiglia di indirizzi
+ \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
+ \item[\errcode{EINPROGRESS}] il socket è non bloccante (vedi
+ \secref{sec:file_noblocking}) e la connessione non può essere conclusa
+ immediatamente.
+ \item[\errcode{EALREADY}] il socket è non bloccante (vedi
+ \secref{sec:file_noblocking}) e un tentativo precedente di connessione non
+ si è ancora concluso.
+ \item[\errcode{EAGAIN}] non ci sono più porte locali libere.
+ \item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
corretta nel relativo campo.
- \item \macro{EACCESS, EPERM} si è tentato di eseguire una connessione ad un
- indirizzo broadcast senza che il socket fosse stato abilitato per il
- broadcast.
+ \item[\errcode{EACCES}, \errcode{EPERM}] si è tentato di eseguire una
+ connessione ad un indirizzo broadcast senza che il socket fosse stato
+ abilitato per il broadcast.
\end{errlist}
- altri errori possibili sono: \macro{EFAULT}, \macro{EBADF},
- \macro{ENOTSOCK}.
+ altri errori possibili sono: \errval{EFAULT}, \errval{EBADF},
+ \errval{ENOTSOCK}, \errval{EISCONN} e \errval{EADDRINUSE}.}
\end{prototype}
+Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
+\func{socket}, mentre il secondo e terzo argomento sono rispettivamente
+l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
+socket, già descritta in \secref{sec:sock_sockaddr}.
+
La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
numero di porta del server a cui ci si vuole connettere, come mostrato
-nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
+nell'esempio \secref{sec:TCP_daytime_client}, usando le funzioni illustrate in
\secref{sec:sock_addr_func}.
Nel caso di socket TCP la funzione \func{connect} avvia il \textit{three way
seguenti:
\begin{enumerate}
\item Il client non riceve risposta al SYN: l'errore restituito è
- \macro{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
+ \errcode{ETIMEDOUT}. Stevens riporta che BSD invia un primo SYN alla chiamata
di \func{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
\func{sysctl} che attraverso il filesystem \file{/proc} scrivendo il valore
- voluto in \file{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore di default
+ voluto in \file{/proc/sys/net/ipv4/tcp\_syn\_retries}. Il valore predefinito
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
+% Le informazioni su tutte le opzioni impostabili via /proc stanno in
% Linux/Documentation/networking/ip-sysctl.txt
%
\item Il client riceve come risposta al SYN un RST significa che non c'è
che vuol dire probabilmente 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
- \macro{ECONNREFUSED}.
+ \errcode{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:
essere dovuto ad una condizione transitoria si ripete l'emissione dei SYN
come nel caso precedente, fino al timeout, e solo allora si restituisce il
codice di errore dovuto al messaggio ICMP, che da luogo ad un
- \macro{ENETUNREACH}.
+ \errcode{ENETUNREACH}.
\end{enumerate}
\subsection{La funzione \func{listen}}
-\label{sec:TCPel_func_listen}
+\label{sec:TCP_func_listen}
-La funzione \func{listen} è usata per usare un socket in modalità passiva,
-cioè, come dice il nome, per metterlo in ascolto di eventuali connessioni; in
+La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
+come dice il nome, per metterlo in ascolto di eventuali connessioni; in
sostanza l'effetto della funzione è di portare il socket dallo stato
\texttt{CLOSED} a quello \texttt{LISTEN}. In genere si chiama la funzione in
un server dopo le chiamate a \func{socket} e \func{bind} e prima della
-chiamata ad \func{accept}. Il prototipo della funzione come definito dalla
-man page è:
+chiamata ad \func{accept}. Il prototipo della funzione, come definito dalla
+pagina di manuale, è:
\begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
- La funzione pone il socket specificato da \var{sockfd} in modalità
- passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
- a \var{backlog}. La funzione si può applicare solo a socket di tipo
- \macro{SOCK\_STREAM} o \macro{SOCK\_SEQPACKET}.
-
- La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
- codici di errore restituiti in \var{errno} sono i seguenti:
+ Pone un socket in attesa di una connessione.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+ errore. I codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
valido.
- \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
- \item \macro{EOPNOTSUPP} il socket è di un tipo che non supporta questa
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
+ \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
operazione.
- \end{errlist}
+ \end{errlist}}
\end{prototype}
+La funzione pone il socket specificato da \param{sockfd} in modalità passiva e
+predispone una coda per le connessioni in arrivo di lunghezza pari a
+\param{backlog}. La funzione si può applicare solo a socket di tipo
+\const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}.
-Il parametro \var{backlog} indica il numero massimo di connessioni pendenti
-accettate; se esso viene ecceduto il client riceverà una errore di tipo
-\macro{ECONNREFUSED}, o se il protocollo, come nel caso del TCP, supporta la
-ritrasmissione, la richiesta sarà ignorata in modo che la connessione possa
-essere ritentata.
+L'argomento \param{backlog} indica il numero massimo di connessioni pendenti
+accettate; se esso viene ecceduto il client al momento della richiesta della
+connessione riceverà un errore di tipo \errcode{ECONNREFUSED}, o se il
+protocollo, come accade nel caso del TCP, supporta la ritrasmissione, la
+richiesta sarà ignorata in modo che la connessione possa venire ritentata.
Per capire meglio il significato di tutto ciò occorre approfondire la modalità
con cui il kernel tratta le connessioni in arrivo. Per ogni socket in ascolto
infatti vengono mantenute due code:
\begin{enumerate}
-\item Una coda delle connessioni incomplete (\textit{incomplete connection
- queue} che contiene un ingresso per ciascun socket per il quale è arrivato
- un SYN ma il three way handshake non si è ancora concluso. Questi socket
- sono tutti nello stato \texttt{SYN\_RECV}.
-\item Una coda delle connessioni complete (\textit{complete connection queue}
+\item La coda delle connessioni incomplete (\textit{incomplete connection
+ queue} che contiene un riferimento per ciascun socket per il quale è
+ arrivato un SYN ma il \textit{three way handshake} non si è ancora concluso.
+ Questi socket sono tutti nello stato \texttt{SYN\_RECV}.
+\item La coda delle connessioni complete (\textit{complete connection queue}
che contiene un ingresso per ciascun socket per il quale il three way
handshake è stato completato ma ancora \func{accept} non è ritornata.
Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
\end{enumerate}
-Lo schema di funzionamento è descritto in \nfig, quando arriva un SYN da un
-client il server crea una nuova entrata nella coda delle connessioni
-incomplete, e poi risponde con il SYN$+$ACK. La entrata resterà nella coda
-delle connessioni incomplete fino al ricevimento dell'ACK dal client o fino ad
-un timeout. Nel caso di completamento del three way handshake l'entrata viene
-sostata nella coda delle connessioni complete. Quando il processo chiama la
-funzione \func{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
-entrata nella coda delle connessioni complete è passata al programma, o, se la
-coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo della
-prima connessione completa.
-
-Storicamente il valore del parametro \var{backlog} era corrispondente al
-massimo valore della somma del numero di entrate possibili per ciascuna di
-dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
-valore, e provvede una tabella con i risultati ottenuti con vari kernel,
-compreso Linux 2.0, che mostrano le differenze fra diverse implementazioni.
-
-In Linux il significato di questo valore è cambiato a partire dal kernel
-2.2 per prevenire l'attacco chiamato \textit{syn flood}. Questo si basa
+Lo schema di funzionamento è descritto in \figref{fig:TCP_listen_backlog}:
+quando arriva un SYN da un client il server crea una nuova voce nella coda
+delle connessioni incomplete, e poi risponde con il SYN$+$ACK. La voce resterà
+nella coda delle connessioni incomplete fino al ricevimento dell'ACK dal
+client o fino ad un timeout. Nel caso di completamento del three way handshake
+la voce viene spostata nella coda delle connessioni complete. Quando il
+processo chiama la funzione \func{accept} (vedi \secref{sec:TCP_func_accept})
+la prima voce nella coda delle connessioni complete è passata al programma, o,
+se la coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo
+della prima connessione completa.
+
+\begin{figure}[htb]
+ \centering
+ \includegraphics[width=11cm]{img/tcp_listen_backlog}
+ \caption{Schema di funzionamento delle code delle connessioni complete ed
+ incomplete.}
+ \label{fig:TCP_listen_backlog}
+\end{figure}
+
+Storicamente il valore del parametro \param{backlog} era corrispondente al
+massimo valore della somma del numero di voci possibili per ciascuna delle due
+code. Stevens in \cite{UNP1} riporta che BSD ha sempre applicato un fattore di
+1.5 a detto valore, e fornisce una tabella con i risultati ottenuti con vari
+kernel, compreso Linux 2.0, che mostrano le differenze fra diverse
+implementazioni.
+
+In Linux il significato di questo valore è cambiato a partire dal kernel 2.2
+per prevenire l'attacco chiamato \textit{syn flood}. Questo si basa
sull'emissione da parte dell'attaccante di un grande numero di pacchetti SYN
-indirizzati verso una porta forgiati con indirizzo IP fasullo\footnote{con la
- tecnica che viene detta \textit{ip spoofing}} così che i SYN$+$ACK vanno
+indirizzati verso una porta, forgiati con indirizzo IP fasullo\footnote{con la
+ tecnica che viene detta \textit{ip spoofing}.} così che i SYN$+$ACK vanno
perduti e la coda delle connessioni incomplete viene saturata, impedendo di
fatto ulteriori connessioni.
-Per ovviare a questo il significato del \var{backlog} è stato cambiato a
+Per ovviare a questo il significato del \param{backlog} è stato cambiato a
indicare la lunghezza della coda delle connessioni complete. La lunghezza
della coda delle connessioni incomplete può essere ancora controllata usando
-la \func{sysctl} o scrivendola direttamente in
-\file{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
+la funzione \func{sysctl} con il parametro \const{NET\_TCP\_MAX\_SYN\_BACKLOG}
+o scrivendola direttamente in
+\file{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
protezione dei syncookies però (con l'opzione da compilare nel kernel e da
-attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
-viene ignorato e non esiste più un valore massimo. In ogni caso in Linux il
-valore di \var{backlog} viene troncato ad un massimo di \macro{SOMAXCONN}
-se è superiore a detta costante (che di default vale 128).
+attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore viene
+ignorato e non esiste più un valore massimo. In ogni caso in Linux il valore
+di \param{backlog} viene troncato ad un massimo di \const{SOMAXCONN} se è
+superiore a detta costante (che di default vale 128).
-La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
+La scelta storica per il valore di questo parametro era di 5, e alcuni vecchi
kernel non supportavano neanche valori superiori, ma la situazione corrente è
molto cambiata per via della presenza di server web che devono gestire un gran
numero di connessioni per cui un tale valore non è più adeguato. Non esiste
comunque una risposta univoca per la scelta del valore, per questo non
conviene specificarlo con una costante (il cui cambiamento richiederebbe la
ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi
-\secref{sec:proc_environ}).
-
-Lo Stevens tratta accuratamente questo argomento, con esempi presi da casi
-reali su web server, ed in particolare evidenzia come non sia più vero che il
-compito principale della coda sia quello di gestire il caso in cui il server è
-occupato fra chiamate successive alla \func{accept} (per cui la coda più
-occupata sarebbe quella delle connessioni completate), ma piuttosto quello di
-gestire la presenza di un gran numero di SYN in attesa di concludere il
+\secref{sec:proc_environ}).
+
+Stevens tratta accuratamente questo argomento in \cite{UNP1}, con esempi presi
+da casi reali su web server, ed in particolare evidenzia come non sia più vero
+che il compito principale della coda sia quello di gestire il caso in cui il
+server è occupato fra chiamate successive alla \func{accept} (per cui la coda
+più occupata sarebbe quella delle connessioni completate), ma piuttosto quello
+di gestire la presenza di un gran numero di SYN in attesa di concludere il
three way handshake.
-Infine va messo in evidenza che nel caso di socket TCP quando un SYN arriva
+Infine va messo in evidenza che, nel caso di socket TCP, quando un SYN arriva
con tutte le code piene, il pacchetto deve essere ignorato. Questo perché la
condizione in cui le code sono piene è ovviamente transitoria, per cui se il
client ritrasmette il SYN è probabile che passato un po' di tempo possa
trovare nella coda lo spazio per una nuova connessione. Se invece si
-rispondesse con un RST per indicare l'impossibilità di effettuare la
-connessione la chiamata a \func{connect} nel client ritornerebbe con una
+rispondesse con un RST, per indicare l'impossibilità di effettuare la
+connessione, la chiamata a \func{connect} nel client ritornerebbe con una
condizione di errore, costringendo a inserire nell'applicazione la gestione
-dei tentativi di riconnessione che invece può essere effettuata in maniera
+dei tentativi di riconnessione, che invece può essere effettuata in maniera
trasparente dal protocollo TCP.
\subsection{La funzione \func{accept}}
-\label{sec:TCPel_func_accept}
+\label{sec:TCP_func_accept}
-La funzione \func{accept} è chiamata da un server TCP per gestire la
-connessione una volta che sia stato completato il three way handshake, la
+La funzione \funcd{accept} è chiamata da un server per gestire la connessione
+una volta che sia stato completato il \textit{three way handshake}, la
funzione restituisce un nuovo socket descriptor su cui si potrà operare per
effettuare la comunicazione. Se non ci sono connessioni completate il processo
viene messo in attesa. Il prototipo della funzione è il seguente:
\begin{prototype}{sys/socket.h}
{int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
- La funzione estrae la prima connessione relativa al socket \var{sockfd}
- in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
- con le stesse caratteristiche di \var{sockfd} (restituito dalla funzione
- stessa). Il socket originale non viene toccato. Nella struttura
- \var{addr} e nella variabile \var{addrlen} vengono restituiti
- indirizzo e relativa lunghezza del client che si è connesso.
- La funzione restituisce un numero di socket descriptor positivo in caso di
- successo e -1 in caso di errore, nel qual caso la variabile \var{errno}
- viene settata ai seguenti valori:
+ Accetta una connessione sul socket specificato.
+
+ \bodydesc{La funzione restituisce un numero di socket descriptor positivo in
+ caso di successo e -1 in caso di errore, nel qual caso \var{errno} viene
+ impostata ai seguenti valori:
\begin{errlist}
- \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
valido.
- \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
- \item \macro{EOPNOTSUPP} il socket è di un tipo che non supporta questa
- operazione.
- \item \macro{EAGAIN} o \macro{EWOULDBLOCK} il socket è stato settato come
- non bloccante, e non ci sono connessioni in attesa di essere accettate.
- \item \macro{EFAULT} l'argomento \var{addr} .
- \item \macro{EPERM} Firewall rules forbid connection.
-
- \item \macro{ENOBUFS, ENOMEM} Not enough free memory. This often means
- that the memory allocation is limited by the socket buffer limits, not by
- the system memory.
-
- Inoltre possono essere restituiti gli errori di rete relativi al nuovo
- socket come: \macro{EMFILE}, \macro{EINVAL}, \macro{ENOSR},
- \macro{ENOBUFS}, \macro{EPERM}, \macro{ECONNABORTED},
- \macro{ESOCKTNOSUPPORT}, \macro{EPROTONOSUPPORT}, \macro{ETIMEDOUT},
- \macro{ERESTARTSYS}.
-
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
+ \item[\errcode{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
+ operazione.
+ \item[\errcode{EAGAIN} o \errcode{EWOULDBLOCK}] il socket è stato impostato
+ come non bloccante (vedi \secref{sec:file_noblocking}), e non ci sono
+ connessioni in attesa di essere accettate.
+ \item[\errcode{EPERM}] Le regole del firewall non consentono la connessione.
+ \item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che
+ l'allocazione della memoria è limitata dai limiti sui buffer dei socket,
+ non dalla memoria di sistema.
+ \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale.
\end{errlist}
+ Inoltre possono essere restituiti gli errori di rete relativi al nuovo
+ socket, diversi a secondo del protocollo, come: \errval{EMFILE},
+ \errval{EINVAL}, \errval{ENOSR}, \errval{ENOBUFS}, \errval{EFAULT},
+ \errval{EPERM}, \errval{ECONNABORTED}, \errval{ESOCKTNOSUPPORT},
+ \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT}, \errval{ERESTARTSYS}.}
\end{prototype}
-La funzione può essere usata solo con socket che supportino la connessione
-(cioè di tipo \macro{SOCK\_STREAM}, \macro{SOCK\_SEQPACKET} o
-\macro{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
-esplicita della connessione, (attualmente in Linux solo DECnet ha questo
-comportamento), la funzione opera solo l'estrazione dalla coda delle
-connessioni, la conferma della connessione viene fatta implicitamente dalla
-prima chiamata ad una \func{read} o una \func{write} mentre il rifiuto
-della connessione viene fatto con la funzione \func{close}.
+La funzione estrae la prima connessione relativa al socket \param{sockfd} in
+attesa sulla coda delle connessioni complete, che associa ad nuovo socket con
+le stesse caratteristiche di \param{sockfd}. Il socket originale non viene
+toccato e resta nello stato di \texttt{LISTEN}, mentre il nuovo socket viene
+posto nello stato \texttt{ESTABLISHED}. Nella struttura \param{addr} e nella
+variabile \param{addrlen} vengono restituiti indirizzo e relativa lunghezza
+del client che si è connesso.
-È da chiarire che Linux presenta un comportamento diverso nella gestione degli
-errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
-\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
-di errore per \func{accept}. Inoltre la funzione non fa ereditare ai nuovi
-socket flag come \macro{O\_NONBLOCK}, che devono essere rispecificati volta
-volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
-deve essere tenuto in conto per scrivere programmi portabili.
-
-I due argomenti \var{cliaddr} e \var{addrlen} (si noti che quest'ultimo
-è passato per indirizzo per avere indietro il valore) sono usati per ottenere
+I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è
+passato per indirizzo per avere indietro il valore) sono usati per ottenere
l'indirizzo del client da cui proviene la connessione. Prima della chiamata
-\var{addrlen} deve essere inizializzato alle dimensioni della struttura il
-cui indirizzo è passato come argomento in \var{cliaddr}, al ritorno della
-funzione \var{addrlen} conterrà il numero di bytes scritti dentro
-\var{cliaddr}. Se questa informazione non interessa basterà inizializzare a
-\macro{NULL} detti puntatori.
+\param{addrlen} deve essere inizializzato alle dimensioni della struttura il
+cui indirizzo è passato come argomento in \param{addr}; al ritorno della
+funzione \param{addrlen} conterrà il numero di byte scritti dentro
+\param{addr}. Se questa informazione non interessa basterà inizializzare a
+\val{NULL} detti puntatori.
Se la funzione ha successo restituisce il descrittore di un nuovo socket
creato dal kernel (detto \textit{connected socket}) a cui viene associata la
prima connessione completa (estratta dalla relativa coda, vedi
-\secref{sec:TCPel_func_listen}) che il client TCP ha effettuato verso il
-socket \var{sockfd}. Quest'ultimo (detto \textit{listening socket}) è
-quello creato all'inizio e messo in ascolto con \func{listen}, e non viene
-toccato dalla funzione.
-Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
-il processo\footnote{a meno che non si sia settato il socket per essere
- non-bloccante, nel qual caso ritorna con l'errore \func{EAGAIN},
- torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
-fintanto che non ne arriva una.
-
+\secref{sec:TCP_func_listen}) che il client ha effettuato verso il socket
+\param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato
+all'inizio e messo in ascolto con \func{listen}, e non viene toccato dalla
+funzione. Se non ci sono connessioni pendenti da accettare la funzione mette
+in attesa il processo\footnote{a meno che non si sia impostato il socket per
+ essere non bloccante (vedi \secref{sec:file_noblocking}), nel qual caso
+ ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di
+ operazione in \secref{sec:xxx_sock_noblock}.} fintanto che non ne arriva
+una.
+
+La funzione può essere usata solo con socket che supportino la connessione
+(cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o
+\const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
+esplicita della connessione,\footnote{attualmente in Linux solo DECnet ha
+ questo comportamento.} la funzione opera solo l'estrazione dalla coda delle
+connessioni, la conferma della connessione viene eseguita implicitamente dalla
+prima chiamata ad una \func{read} o una \func{write}, mentre il rifiuto della
+connessione viene eseguito con la funzione \func{close}.
+
+È da chiarire che Linux presenta un comportamento diverso nella gestione degli
+errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
+\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
+di errore per \func{accept}, per cui l'applicazione deve tenerne conto ed
+eventualmente ripetere la chiamata alla funzione come per l'errore di
+\errcode{EAGAIN} (torneremo su questo in \secref{sec:TCP_echo_critical}).
+Un'altra differenza con BSD è che la funzione non fa ereditare al nuovo socket
+i flag del socket originale, come \const{O\_NONBLOCK},\footnote{ed in generale
+ tutti quelli che si possono impostare con \func{fcntl}, vedi
+ \secref{sec:file_fcntl}.} che devono essere rispecificati ogni volta. Tutto
+questo deve essere tenuto in conto se si devono scrivere programmi portabili.
+
Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
funzionamento di un server: in generale infatti c'è sempre un solo socket in
-ascolto, che resta per tutto il tempo nello stato \texttt{LISTEN}, mentre le
-connessioni vengono gestite dai nuovi socket ritornati da \func{accept} che
-si trovano automaticamente nello stato \texttt{ESTABLISHED} e utilizzati fino
-alla chiusura della connessione che avviene su di essi. Si può riconoscere
-questo schema anche nell'esempio elementare in \figref{fig:net_serv_code} dove
-per ogni connessione il socket creato da \func{accept} viene chiuso dopo
-l'invio dei dati.
+ascolto, detto per questo \textit{listening socket}, che resta per tutto il
+tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai
+nuovi socket, detti \textit{connected socket}, ritornati da \func{accept}, che
+si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono
+utilizzati per lo scambio dei dati, che avviene su di essi, fino alla chiusura
+della connessione. Si può riconoscere questo schema anche nell'esempio
+elementare di \figref{fig:TCP_daytime_iter_server_code}, dove per ogni
+connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei
+dati.
+
+
+\subsection{Le funzioni \func{getsockname} e \func{getpeername}}
+\label{sec:TCP_get_names}
+
+Oltre a tutte quelle viste finora, dedicate all'utilizzo dei socket, esistono
+alcune funzioni ausiliarie che possono essere usate per recuperare alcune
+informazioni relative ai socket ed alle connessioni ad essi associate. Le due
+funzioni più elementari sono queste, che vengono usate per ottenere i dati
+relativi alla socket pair associata ad un certo socket.
+
+La prima funzione è \funcd{getsockname} e serve ad ottenere l'indirizzo locale
+associato ad un socket; il suo prototipo è:
+\begin{prototype}{sys/socket.h}
+ {int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+ Legge l'indirizzo locale di un socket.
+
+\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+ errore. I codici di errore restituiti in \var{errno} sono i seguenti:
+ \begin{errlist}
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ valido.
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
+ \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
+ eseguire l'operazione.
+ \item[\errcode{EFAULT}] l'indirizzo \param{name} non è valido.
+ \end{errlist}}
+\end{prototype}
+
+La funzione restituisce la struttura degli indirizzi del socket \param{sockfd}
+nella struttura indicata dal puntatore \param{name} la cui lunghezza è
+specificata tramite l'argomento \param{namlen}. Quest'ultimo viene passato
+come indirizzo per avere indietro anche il numero di byte effettivamente
+scritti nella struttura puntata da \param{name}. Si tenga presente che se si è
+utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà
+troncato.
+
+La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un
+socket; ad esempio può essere usata da un client (che usualmente non chiama
+\func{bind}) per ottenere numero IP e porta locale associati al socket
+restituito da una \func{connect}, o da un server che ha chiamato \func{bind}
+su un socket usando 0 come porta locale per ottenere il numero di porta
+effimera assegnato dal kernel.
+
+Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se
+chiamata dopo il completamento di una connessione sul socket restituito da
+\func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
+quella connessione.
+
+Tutte le volte che si vuole avere l'indirizzo remoto di un socket si usa la
+funzione \funcd{getpeername}, il cui prototipo è:
+\begin{prototype}{sys/socket.h}
+ {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+ Legge l'indirizzo remoto di un socket.
+
+ \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+ errore. I codici di errore restituiti in \var{errno} sono i seguenti:
+ \begin{errlist}
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ valido.
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
+ \item[\errcode{ENOTCONN}] il socket non è connesso.
+ \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
+ eseguire l'operazione.
+ \item[\errcode{EFAULT}] l'argomento \param{name} punta al di fuori dello
+ spazio di indirizzi del processo.
+ \end{errlist}}
+\end{prototype}
+
+La funzione è identica a \func{getsockname}, ed usa la stessa sintassi, ma
+restituisce l'indirizzo remoto del socket, cioè quello associato all'altro
+capo della connessione. Ci si può chiedere a cosa serva questa funzione dato
+che dal lato client l'indirizzo remoto è sempre noto quando si esegue la
+\func{connect} mentre dal lato server si possono usare, come vedremo in
+\figref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di
+\func{accept}.
+
+Il fatto è che in generale quest'ultimo caso non è sempre possibile. In
+particolare questo avviene quando il server, invece di gestire la connessione
+direttamente in un processo figlio, come vedremo nell'esempio di server
+concorrente di \secref{sec:TCP_daytime_cunc_server}, lancia per ciascuna
+connessione un altro programma, usando \func{exec}.\footnote{questa ad esempio
+ è la modalità con cui opera il \textsl{super-server} \cmd{inetd}, che può
+ gestire tutta una serie di servizi diversi, eseguendo su ogni connessione
+ ricevuta sulle porte tenute sotto controllo, il relativo server.}
+
+In questo caso benché il processo figlio abbia una immagine della memoria che
+è copia di quella del processo padre (e contiene quindi anche la struttura
+ritornata da \func{accept}), all'esecuzione di \func{exec} verrà caricata in
+memoria l'immagine del programma eseguito, che a questo punto perde ogni
+riferimento ai valori tornati da \func{accept}. Il socket descriptor però
+resta aperto, e se si è seguita una opportuna convenzione per rendere noto al
+programma eseguito qual'è il socket connesso, \footnote{ad esempio il solito
+ \cmd{inetd} fa sempre in modo che i file descriptor 0, 1 e 2 corrispondano
+ al socket connesso.} quest'ultimo potrà usare la funzione \func{getpeername}
+per determinare l'indirizzo remoto del client.
+
+Infine è da chiarire (si legga la pagina di manuale) che, come per
+\func{accept}, il terzo parametro, che è specificato dallo standard POSIX.1g
+come di tipo \code{socklen\_t *} in realtà deve sempre corrispondere ad un
+\ctyp{int *} come prima dello standard perché tutte le implementazioni dei
+socket BSD fanno questa assunzione.
\subsection{La funzione \func{close}}
-\label{sec:TCPel_func_close}
+\label{sec:TCP_func_close}
-La funzione standard unix \func{close} (vedi \secref{sec:file_close}) che si
-usa sui file può essere usata con lo stesso effetto anche sui socket
-descriptor.
+La funzione standard Unix \func{close} (vedi \secref{sec:file_close}) che si
+usa sui file può essere usata con lo stesso effetto anche sui file descriptor
+associati ad un socket.
-L'azione standard di questa funzione quando applicata a socket è di marcarlo
-come chiuso e ritornare immediatamente al processo. Una volta chiamata il
-socket descriptor non è più utilizzabile dal processo e non può essere usato
-come argomento per una \func{write} o una \func{read} (anche se l'altro
-capo della connessione non avesse chiuso la sua parte). Il kernel invierà
-comunque tutti i dati che ha in coda prima di iniziare la sequenza di chiusura.
+L'azione di questa funzione quando applicata a socket è di marcarlo come
+chiuso e ritornare immediatamente al processo. Una volta chiamata il socket
+descriptor non è più utilizzabile dal processo e non può essere usato come
+argomento per una \func{write} o una \func{read} (anche se l'altro capo della
+connessione non avesse chiuso la sua parte). Il kernel invierà comunque tutti
+i dati che ha in coda prima di iniziare la sequenza di chiusura.
-Vedremo più avanti in \secref{sec:TCPadv_so_linger} come è possibile cambiare
+Vedremo più avanti in \secref{sec:TCP_so_linger} come è possibile cambiare
questo comportamento, e cosa deve essere fatto perché il processo possa
assicurarsi che l'altro capo abbia ricevuto tutti i dati.
-Come per i file anche per i socket descriptor viene mantenuto un numero di
-riferimenti, per cui se più di un processo ha lo stesso socket aperto
+Come per tutti i file descriptor anche per i socket viene mantenuto un numero
+di riferimenti, per cui se più di un processo ha lo stesso socket aperto
l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
-fintanto che il numero di riferimenti non si annulla. Questo è il
-comportamento normale che ci si aspetta in un'applicazione client/server quale
-quella che illustreremo in \secref{sec:TCPel_cunc_serv}.
+fintanto che il numero di riferimenti non si annulla, questo si applica, come
+visto in \secref{sec:file_sharing}, sia ai file descriptor duplicati che a
+quelli ereditati dagli eventuali processi figli, ed è il comportamento che ci
+si aspetta in una qualunque applicazione client/server.
+
+Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura
+descritta in \secref{sec:TCP_conn_term}, si può invece usare la funzione
+\func{shutdown} su cui torneremo in seguito (vedi \secref{sec:xxx_shutdown}).
+
+
+
+\section{Un esempio elementare: il servizio \textit{daytime}}
+\label{sec:TCP_daytime_application}
-Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura si
-può usare la funzione \func{shutdown} su cui torneremo in seguito.
+Avendo introdotto le funzioni di base per la gestione dei socket, potremo
+vedere in questa sezione un primo esempio di applicazione elementare che
+implementa il servizio \textit{daytime} su TCP, secondo quanto specificato
+dall'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}. Prima di passare
+agli esempi del client e del server, inizieremo riesaminando con maggiori
+dettagli una peculiarità delle funzioni di I/O, già accennata in
+\secref{sec:file_read} e \secref{sec:file_write}, che nel caso dei socket è
+particolarmente rilevante. Passeremo poi ad illustrare gli esempi
+dell'implementazione, sia dal lato client, che dal lato server, che si è
+realizzato sia in forma iterativa che concorrente.
+\subsection{Il comportamento delle funzioni di I/O}
+\label{sec:sock_io_behav}
-\section{I server concorrenti su TCP}
-\label{sec:TCPel_cunc_serv}
+Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
+le funzioni di input/output non sempre hanno lo stesso comportamento che
+avrebbero con i normali file di dati (in particolare questo accade per i
+socket di tipo stream).
-Il server \texttt{daytime} dell'esempio in \secref{sec:net_cli_sample} è un
-tipico esempio di server iterativo, in cui viene servita una richiesta alla
-volta; in generale però, specie se il servizio è più complesso e comporta uno
-scambio di dati più sostanzioso di quello in questione, non è opportuno
-bloccare un server nel servizio di un client per volta; per questo si ricorre
-alle capacità di multitasking del sistema.
+Infatti con i socket è comune che funzioni come \func{read} o \func{write}
+possano restituire in input o scrivere in output un numero di byte minore di
+quello richiesto. Come già accennato in \secref{sec:file_read} questo è un
+comportamento normale per le funzioni di I/O, ma con i normali file di dati il
+problema si avverte solo in lettura, quando si incontra la fine del file. In
+generale non è così, e con i socket questo è particolarmente evidente.
-Il modo più immediato per creare un server concorrente è allora quello di
-usare la funzione \func{fork} per far creare al server per ogni richiesta da
-parte di un client un processo figlio che si incarichi della gestione della
-comunicazione.
+\begin{figure}[htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/FullRead.c}
+ \end{minipage}
+ \normalsize
+ \caption{La funzione \func{FullRead}, che legge esattamente \var{count} byte
+ da un file descriptor, iterando opportunamente le letture.}
+ \label{fig:sock_FullRead_code}
+\end{figure}
-\subsection{Un esempio di server \textit{daytime} concorrente}
-\label{sec:TCPel_cunc_daytime}
+Quando ci si trova ad affrontare questo comportamento tutto quello che si deve
+fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di
+byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non
+sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
+\const{PIPE\_BUF} byte in una pipe (si riveda quanto detto in
+\secref{sec:ipc_pipes}).
+
+Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono
+definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono
+lettura e scrittura tenendo conto di questa caratteristica, ed in grado di
+ritornare solo dopo avere letto o scritto esattamente il numero di byte
+specificato; il sorgente è riportato rispettivamente in
+\figref{fig:sock_FullRead_code} e \figref{fig:sock_FullWrite_code} ed è
+disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
+\file{FullWrite.c}.
-Per illustrare il meccanismo usato in generale per creare un server
-concorrente abbiamo riscritto il server \texttt{daytime} dell'esempio
-precedente in forma concorrente, inserendo anche una opzione per la stampa
-degli indirizzi delle connessioni ricevute.
+\begin{figure}[htb]
+ \centering
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/FullWrite.c}
+ \end{minipage}
+ \normalsize
+ \caption{La funzione \func{FullWrite}, che scrive esattamente \var{count}
+ byte su un file descriptor, iterando opportunamente le scritture.}
+ \label{fig:sock_FullWrite_code}
+\end{figure}
-In \nfig\ è mostrato un estratto del codice, in cui si sono tralasciati il
-trattamento delle opzioni e le parti rimaste invariate rispetto al precedente
-esempio. Al solito il sorgente completo del server
-\file{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti.
+Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo
+fino all'esaurimento del numero di byte richiesti, in caso di errore viene
+controllato se questo è \errcode{EINTR} (cioè un'interruzione della system
+call dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
+l'errore viene ritornato al programma chiamante, interrompendo il ciclo.
+
+Nel caso della lettura, se il numero di byte letti è zero, significa che si è
+arrivati alla fine del file (per i socket questo significa in genere che
+l'altro capo è stato chiuso, e quindi non sarà più possibile leggere niente) e
+pertanto si ritorna senza aver concluso la lettura di tutti i byte
+richiesti. Entrambe le funzioni restituiscono 0 in caso di successo, ed un
+valore negativo in caso di errore, \texttt{FullRead} restituisce il numero di
+byte non letti in caso di end-of-file prematuro.
+
+
+\subsection{Il client \textit{daytime}}
+\label{sec:TCP_daytime_client}
+
+Il primo esempio di applicazione delle funzioni di base illustrate in
+\secref{sec:TCP_functions} è relativo alla creazione di un client elementare
+per il servizio \textit{daytime}, un servizio elementare, definito
+nell'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}, che restituisce
+l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
+alla porta 13.
+
+In \figref{fig:TCP_daytime_client_code} è riportata la sezione principale del
+codice del nostro client. Il sorgente completo del programma
+(\file{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una
+funzione per stampare un messaggio di aiuto) è allegato alla guida nella
+sezione dei codici sorgente e può essere compilato su una qualunque macchina
+GNU/Linux.
\begin{figure}[!htb]
- \footnotesize
- \begin{lstlisting}{}
-#include <sys/types.h> /* predefined types */
-#include <unistd.h> /* include unix standard library */
-#include <arpa/inet.h> /* IP addresses conversion utiliites */
-#include <sys/socket.h> /* socket library */
-#include <stdio.h> /* include standard I/O library */
-#include <time.h>
-
-int main(int argc, char *argv[])
-{
- int list_fd, conn_fd;
- int i;
- struct sockaddr_in serv_add, client;
- char buffer[MAXLINE];
- socklen_t len;
- time_t timeval;
- pid_t pid;
- int logging=0;
- ...
- /* write daytime to client */
- while (1) {
- if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len))
- <0 ) {
- perror("accept error");
- exit(-1);
- }
- /* fork to handle connection */
- if ( (pid = fork()) < 0 ){
- perror("fork error");
- exit(-1);
- }
- if (pid == 0) { /* child */
- close(list_fd);
- timeval = time(NULL);
- snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
- if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
- perror("write error");
- exit(-1);
- }
- if (logging) {
- inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
- printf("Request from host %s, port %d\n", buffer,
- ntohs(client.sin_port));
- }
- close(conn_fd);
- exit(0);
- } else { /* parent */
- close(conn_fd);
- }
- }
- /* normal exit, never reached */
- exit(0);
-}
- \end{lstlisting}
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/TCP_daytime.c}
+ \end{minipage}
+ \normalsize
+ \caption{Esempio di codice di un client elementare per il servizio
+ \textit{daytime}.}
+ \label{fig:TCP_daytime_client_code}
+\end{figure}
+
+Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari;
+dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
+tutta la parte relativa al trattamento degli argomenti passati dalla linea di
+comando (effettuata con le apposite funzioni illustrate in
+\secref{sec:proc_opt_handling}).
+
+Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo
+\const{SOCK\_STREAM} e di famiglia \const{AF\_INET}). La funzione
+\func{socket} ritorna il descrittore che viene usato per identificare il
+socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
+stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce
+(\texttt{\small 17}) con un codice di errore.
+
+Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
+struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
+il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è
+inizializzare tutto a zero, per poi inserire il tipo di indirizzo
+(\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima
+la funzione \func{htons} per convertire il formato dell'intero usato dal
+computer a quello usato nella rete, infine \texttt{\small 23--27} si può
+utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico
+passato dalla linea di comando.
+
+A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul
+socket creato in precedenza (\texttt{\small 29}) si può stabilire la
+connessione con il server. Per questo si deve utilizzare come secondo
+argomento la struttura preparata in precedenza con il relativo indirizzo; si
+noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast.
+Un valore di ritorno della funzione negativo implica il fallimento della
+connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si
+ritorna (\texttt{\small 31}).
+
+Completata con successo la connessione il passo successivo (\texttt{\small
+ 34--40}) è leggere la data dal socket; il protocollo prevede che il server
+invii sempre una stringa alfanumerica, il formato della stringa non è
+specificato dallo standard, per cui noi useremo il formato usato dalla
+funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè
+qualcosa del tipo:
+\begin{verbatim}
+Wed Apr 4 00:53:00 2001\r\n
+\end{verbatim}
+questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read}
+in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small
+ 35}) con il solito carattere nullo per poter essere stampata (\texttt{\small
+ 36}) sullo standard output con l'uso di \func{fputs}.
+
+Come si è già spiegato in \secref{sec:sock_io_behav} la risposta dal socket
+potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel
+caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte. Per
+questo nel caso generale non si può mai assumere che tutti i dati arrivino con
+una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo
+in cui si continui a leggere fintanto che la funzione \func{read} non ritorni
+uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero
+minore di zero (che significa un errore nella connessione).
+
+Si noti come in questo caso la fine dei dati sia specificata dal server che
+chiude la connessione (anche questo è quanto richiesto dal protocollo); questa
+è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma
+ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco
+di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed),
+mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il
+punto essenziale è che TCP non provvede nessuna indicazione che permetta di
+marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il
+programma stesso.
+
+Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene
+ fornito direttamente dal \textsl{superdemone} \texttt{inetd}, pertanto basta
+ assicurarsi che esso sia abilitato nel relativo file di configurazione.}
+possiamo verificare il funzionamento del nostro client, avremo allora:
+\begin{verbatim}
+[piccardi@gont sources]$ ./daytime 127.0.0.1
+Mon Apr 21 20:46:11 2003
+\end{verbatim}%$
+e come si vede tutto funziona regolarmente.
+
+
+\subsection{Un server \textit{daytime} iterativo}
+\label{sec:TCP_daytime_iter_server}
+
+Dopo aver illustrato il client daremo anche un esempio di un server
+elementare, che sia anche in grado di rispondere al precedente client. Come
+primo esempio realizzeremo un server iterativo, in grado di fornire una sola
+risposta alla volta. Il codice del programma è nuovamente mostrato in
+\figref{fig:TCP_daytime_iter_server_code}, il sorgente completo
+(\file{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli esempi.
+
+\begin{figure}[!htbp]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/TCP_iter_daytimed.c}
+ \end{minipage}
+ \normalsize
+ \caption{Esempio di codice di un semplice server per il servizio daytime.}
+ \label{fig:TCP_daytime_iter_server_code}
+\end{figure}
+
+Come per il client si includono (\texttt{\small 1--9}) gli header necessari a
+cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small
+ 14--18}) alcune costanti e le variabili necessarie in seguito. Come nel caso
+precedente si sono omesse le parti relative al trattamento delle opzioni da
+riga di comando.
+
+La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente,
+come pure l'inizializzazione (\texttt{\small 25--29}) della struttura
+\struct{sockaddr\_in}. Anche in questo caso (\texttt{\small 28}) si usa la
+porta standard del servizio daytime, ma come indirizzo IP si usa
+(\texttt{\small 27}) il valore predefinito \const{INET\_ANY}, che corrisponde
+all'indirizzo generico.
+
+Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind}
+che permette di associare la precedente struttura al socket, in modo che
+quest'ultimo possa essere usato per accettare connessioni su una qualunque
+delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small
+ 31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il
+programma.
+
+Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``in
+ascolto'' il socket; questo viene fatto (\texttt{\small 36}) con la funzione
+\func{listen} che dice al kernel di accettare connessioni per il socket che
+abbiamo creato; la funzione indica inoltre, con il secondo parametro, il
+numero massimo di connessioni che il kernel accetterà di mettere in coda per
+il suddetto socket. Di nuovo in caso di errore si stampa (\texttt{\small 37})
+un messaggio, e si esce (\texttt{\small 38}) immediatamente.
+
+La chiamata a \func{listen} completa la preparazione del socket per l'ascolto
+(che viene chiamato anche \textit{listening descriptor}) a questo punto si può
+procedere con il ciclo principale (\texttt{\small 40--53}) che viene eseguito
+indefinitamente. Il primo passo (\texttt{\small 42}) è porsi in attesa di
+connessioni con la chiamata alla funzione \func{accept}, come in precedenza in
+caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce
+(\texttt{\small 44}).
+
+Il processo resterà in stato di \textit{sleep} fin quando non arriva e viene
+accettata una connessione da un client; quando questo avviene \func{accept}
+ritorna, restituendo un secondo descrittore, che viene chiamato
+\textit{connected descriptor}, e che è quello che verrà usato dalla successiva
+chiamata alla \func{write} per scrivere la risposta al client.
+
+Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente
+con una chiamata a \texttt{time}, con il quale si potrà opportunamente
+costruire (\texttt{\small 47}) la stringa con la data da trasmettere
+(\texttt{\small 48}) con la chiamata a \func{write}. Completata la
+trasmissione il nuovo socket viene chiuso (\texttt{\small 52}). A questo
+punto il ciclo si chiude ricominciando da capo in modo da poter ripetere
+l'invio della data in risposta ad una successiva connessione.
+
+È importante notare che questo server è estremamente elementare, infatti, a
+parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado
+di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un
+\textsl{server iterativo}. Inoltre è scritto per essere lanciato da linea di
+comando, se lo si volesse utilizzare come demone occorrerebbero le opportune
+modifiche\footnote{come una chiamata a \func{daemon} prima dell'inizio del
+ ciclo principale.} per tener conto di quanto illustrato in
+\secref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma di
+gestione della terminazione del processo, dato che tutti i file descriptor
+vengono chiusi automaticamente alla sua uscita, e che, non generando figli,
+non è necessario preoccuparsi di gestire la loro terminazione.
+
+
+\subsection{Un server \textit{daytime} concorrente}
+\label{sec:TCP_daytime_cunc_server}
+
+Il server \texttt{daytime} dell'esempio in
+\secref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo,
+in cui viene servita una richiesta alla volta; in generale però, specie se il
+servizio è più complesso e comporta uno scambio di dati più sostanzioso di
+quello in questione, non è opportuno bloccare un server nel servizio di un
+client per volta; per questo si ricorre alle capacità di multitasking del
+sistema.
+
+Come accennato anche in \secref{sec:proc_gen} una delle modalità più comuni di
+funzionamento da parte dei server è quella di usare la funzione \func{fork}
+per creare, ad ogni richiesta da parte di un client, un processo figlio che si
+incarichi della gestione della comunicazione. Si è allora riscritto il server
+\textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche
+una opzione per la stampa degli indirizzi delle connessioni ricevute.
+
+In \figref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del
+codice, in cui si sono tralasciati il trattamento delle opzioni e le parti
+rimaste invariate rispetto al precedente esempio (cioè tutta la parte
+riguardante l'apertura passiva del socket). Al solito il sorgente completo del
+server, nel file \file{TCP\_cunc\_daytimed.c}, è allegato insieme ai sorgenti
+degli altri esempi.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15cm}
+ \includecodesample{listati/TCP_cunc_daytimed.c}
+ \end{minipage}
+ \normalsize
\caption{Esempio di codice di un server concorrente elementare per il
servizio daytime.}
- \label{fig:TCPel_serv_code}
+ \label{fig:TCP_daytime_cunc_server_code}
\end{figure}
-Come si può vedere (alle linee \texttt{\small 21--25}) la funzione
-\func{accept} stavolta è chiamata fornendo una struttura di indirizzi in cui
-saranno ritornati numero IP e porta da cui il client effettua la connessione,
-che stamperemo, se avremo abilitato il logging, sullo standard output
-(\texttt{\small 39--43}).
+Stavolta (\texttt{\small 21--25}) la funzione \func{accept} è chiamata
+fornendo una struttura di indirizzi in cui saranno ritornati l'indirizzo IP e
+la porta da cui il client effettua la connessione, che in un secondo tempo,
+(\texttt{\small 39--43}), se il logging è abilitato, stamperemo sullo standard
+output.
Quando \func{accept} ritorna il server chiama la funzione \func{fork}
-(\texttt{\small 26--30}) per creare il processo figlio che effettuerà tutte le
-operazioni relative a quella connessione (\texttt{\small 31--45}), mentre il
-padre resterà in attesa di ulteriori connessioni.
+(\texttt{\small 26--30}) per creare il processo figlio che effettuerà
+(\texttt{\small 31--45}) tutte le operazioni relative a quella connessione,
+mentre il padre proseguirà l'esecuzione del ciclo principale in attesa di
+ulteriori connessioni.
Si noti come il figlio operi solo sul socket connesso, chiudendo
-immediatamente il socket \var{list\_fd}; mentre il padre continua ad operare
-solo sul socket in ascolto chiudendo \var{sock\_fd} dopo ciascuna
-\func{accept}. Per quanto abbiamo detto in \secref{sec:TCPel_func_close}
-queste due chiusure non causano l'innesco della sequenza di chiusura perché il
-numero di riferimenti non si è annullato.
-
-Infatti subito dopo la creazione del socket \var{list\_fd} ha una
-referenza, e lo stesso vale per \var{sock\_fd} dopo il ritorno di
-\func{accept}, ma dopo la fork i descrittori vengono duplicati nel padre e
-nel figlio per cui entrambi i socket si trovano con due referenze. Questo fa
-si che quando il padre chiude \var{sock\_fd} esso resta con una referenza
-da parte del figlio, e sarà definitivamente chiuso solo quando quest'ultimo,
-dopo aver completato le sue operazioni, chiamerà la funzione \func{close}.
-
-In realtà per il figlio non sarebbero necessarie nessuna delle due chiamate a
-\func{close} in quanto nella \func{exit} tutti i file ed i socket vengono
-chiusi, ma si è preferito effettuare la chiusura esplicitamente per avere una
-maggiore chiarezza del codice ed evitare possibili errori.
-
-Si noti come sia essenziale che il padre chiuda ogni volta il socket connesso
-dopo la \func{accept}; se così non fosse nessuno di questi socket sarebbe
-effettivamente chiuso dato che alla chiusura da parte del figlio resterebbe
-ancora un riferimento. Si avrebbero così due effetti, il padre potrebbe
-esaurire i descrittori disponibili (che sono un numero limitato per ogni
-processo) e soprattutto nessuna delle connessioni con i client verrebbe
-chiusa.
+immediatamente (\texttt{\small 32}) il socket \var{list\_fd}; mentre il padre
+continua ad operare (\texttt{\small 47}) solo sul socket in ascolto chiudendo
+\var{sock\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in
+\secref{sec:TCP_func_close} nessuna delle due chiamate a \func{close} causa
+l'innesco della sequenza di chiusura perché il numero di riferimenti al file
+descriptor non si è annullato.
+
+Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e
+lo stesso vale per \var{sock\_fd} dopo il ritorno di \func{accept}, ma dopo la
+\func{fork} i descrittori vengono duplicati nel padre e nel figlio per cui
+entrambi i socket si trovano con due referenze. Questo fa si che quando il
+padre chiude \var{sock\_fd} esso resta con una referenza da parte del figlio,
+e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato
+le sue operazioni, chiamerà (\texttt{\small 44}) la funzione \func{close}.
+
+In realtà per il figlio non sarebbe necessaria nessuna chiamata a
+\func{close}, in quanto con la \func{exit} finale (\texttt{\small 45}) tutti i
+file descriptor, quindi anche quelli associati ai socket, vengono
+automaticamente chiusi. Tuttavia si è preferito effettuare esplicitamente le
+chiusure per avere una maggiore chiarezza del codice, e per evitare eventuali
+errori, prevenendo ad esempio un uso involontario del \textit{listening
+ descriptor}.
+
+Si noti invece come sia essenziale che il padre chiuda ogni volta il socket
+connesso dopo la \func{fork}; se così non fosse nessuno di questi socket
+sarebbe effettivamente chiuso dato che alla chiusura da parte del figlio
+resterebbe ancora un riferimento nel padre. Si avrebbero così due effetti: il
+padre potrebbe esaurire i descrittori disponibili (che sono un numero limitato
+per ogni processo) e soprattutto nessuna delle connessioni con i client
+verrebbe chiusa.
+
+Come per ogni server iterativo il lavoro di risposta viene eseguito
+interamente dal processo figlio. Questo si incarica (\texttt{\small 33}) di
+chiamare \func{time} per leggere il tempo corrente, e di stamparlo
+(\texttt{\small 34}) sulla stringa contenuta in \var{buffer} con l'uso di
+\func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small
+ 35--38}) sul socket, controllando che non ci siano errori. Anche in questo
+caso si è evitato il ricorso a \func{FullWrite} in quanto la stringa è
+estremamente breve e verrà senz'altro scritta in un singolo segmento.
+
+Inoltre nel caso sia stato abilitato il \textit{logging} delle connessioni, si
+provvede anche (\texttt{\small 39--42}) a stampare sullo standard output
+l'indirizzo e la porta da cui il client ha effettuato la connessione, usando
+i valori contenuti nelle strutture restituite da \func{accept}, eseguendo le
+opportune conversioni con \func{inet\_ntop} e \func{atohs}.
+
+Ancora una volta l'esempio è estremamente semplificato, si noti come di nuovo
+non si sia gestita né la terminazione del processo né il suo uso come demone,
+che tra l'altro sarebbe stato incompatibile con l'uso della opzione di logging
+che stampa gli indirizzi delle connessioni sullo standard output. Un altro
+aspetto tralasciato è la gestione della terminazione dei processi figli,
+torneremo su questo più avanti quando tratteremo alcuni esempi di server più
+complessi.
+
+
+
+\section{Un esempio più completo: il servizio \textit{echo}}
+\label{sec:TCP_echo_application}
+
+L'esempio precedente, basato sul servizio \textit{daytime}, è un esempio molto
+elementare, in cui il flusso dei dati va solo nella direzione dal server al
+client. In questa sezione esamineremo un esempio di applicazione client/server
+un po' più complessa, che usi i socket TCP per una comunicazione in entrambe
+le direzioni.
+
+Ci limiteremo a fornire una implementazione elementare, che usi solo le
+funzioni di base viste finora, ma prenderemo in esame, oltre al comportamento
+in condizioni normali, anche tutti i possibili scenari particolari (errori,
+sconnessione della rete, crash del client o del server durante la connessione)
+che possono avere luogo durante l'impiego di un'applicazione di rete, partendo
+da una versione primitiva che dovrà essere rimaneggiata di volta in volta per
+poter tenere conto di tutte le evenienze che si possono manifestare nella vita
+reale di un'applicazione di rete, fino ad arrivare ad un'implementazione
+completa.
+
+
+\subsection{Il servizio \textit{echo}}
+\label{sec:TCP_echo}
+
+
+Nella ricerca di un servizio che potesse fare da esempio per una comunicazione
+bidirezionale, si è deciso, seguendo la scelta di Stevens in \cite{UNP1}, di
+usare il servizio \textit{echo}, che si limita a restituire in uscita quanto
+immesso in ingresso. Infatti, nonostante la sua estrema semplicità, questo
+servizio costituisce il prototipo ideale per una generica applicazione di rete
+in cui un server risponde alle richieste di un client. Nel caso di una
+applicazione più complessa quello che si potrà avere in più è una elaborazione
+dell'input del client, che in molti casi viene interpretato come un comando,
+da parte di un server che risponde fornendo altri dati in uscita.
+
+Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
+direttamente dal superserver \cmd{inetd}, ed è definito
+dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}. Come dice il nome il
+servizio deve riscrivere indietro sul socket i dati che gli vengono inviati in
+ingresso. L'RFC descrive le specifiche del servizio sia per TCP che UDP, e per
+il primo stabilisce che una volta stabilita la connessione ogni dato in
+ingresso deve essere rimandato in uscita fintanto che il chiamante non ha
+chiude la connessione. Al servizio è assegnata la porta riservata 7.
+
+Nel nostro caso l'esempio sarà costituito da un client che legge una linea di
+caratteri dallo standard input e la scrive sul server. A sua volta il server
+leggerà la linea dalla connessione e la riscriverà immutata all'indietro. Sarà
+compito del client leggere la risposta del server e stamparla sullo standard
+output.
+
+
+\subsection{Il client: prima versione}
+\label{sec:TCP_echo_client}
+
+Il codice della prima versione del client per il servizio \textit{echo},
+disponibile nel file \file{TCP\_echo\_first.c}, è riportato in
+\figref{fig:TCP_echo_client_1}. Esso ricalca la struttura del precedente
+client per il servizio \textit{daytime} (vedi
+\secref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27}) è
+sostanzialmente identica, a parte l'uso di una porta diversa.
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6 cm}
+ \includecodesample{listati/TCP_echo_first.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice della prima versione del client \textit{echo}.}
+ \label{fig:TCP_echo_client_1}
+\end{figure}
-\subsection{Le funzioni \func{getsockname} e \func{getpeername}}
-\label{sec:TCPel_get_names}
+Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a
+riga di comando. Una volta dichiarate le variabili, si prosegue
+(\texttt{\small 10--13}) con della creazione del socket con l'usuale controllo
+degli errori, alla preparazione (\texttt{\small 14--17}) della struttura
+dell'indirizzo, che stavolta usa la porta 7 riservata al servizio
+\textit{echo}, infine si converte (\texttt{\small 18--22}) l'indirizzo
+specificato a riga di comando. A questo punto (\texttt{\small 23--27}) si può
+eseguire la connessione al server secondo la stessa modalità usata in
+\secref{sec:TCP_daytime_client}.
+
+Completata la connessione, per gestire il funzionamento del protocollo si usa
+la funzione \code{ClientEcho}, il cui codice si è riportato a parte in
+\figref{fig:TCP_client_echo_sub}. Questa si preoccupa di gestire tutta la
+comunicazione, leggendo una riga alla volta dallo standard input \file{stdin},
+scrivendola sul socket e ristampando su \file{stdout} quanto ricevuto in
+risposta dal server. Al ritorno dalla funzione (\texttt{\small 30--31}) anche
+il programma termina.
+
+La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per
+gestire i dati inviati e letti sul socket. La comunicazione viene gestita
+all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla
+connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets},
+che legge una linea di testo (terminata da un \texttt{CR} e fino al massimo di
+\const{MAXLINE} caratteri) e la salva sul buffer di invio.
+
+Si usa poi (\texttt{\small 6}) la funzione \func{FullWrite}, vista in
+\secref{sec:sock_io_behav}, per scrivere i dati sul socket, gestendo
+automaticamente l'invio multiplo qualora una singola \func{write} non sia
+sufficiente. I dati vengono riletti indietro (\texttt{\small 7}) con una
+\func{read}\footnote{si è fatta l'assunzione implicita che i dati siano
+ contenuti tutti in un solo segmento, così che la chiamata a \texttt{read} li
+ restituisca sempre tutti; avendo scelto una dimensione ridotta per il buffer
+ questo sarà sempre vero, vedremo più avanti come superare il problema di
+ rileggere indietro tutti e soli i dati disponibili, senza bloccarsi.} sul
+buffer di ricezione e viene inserita (\texttt{\small 8}) la terminazione della
+stringa e per poter usare (\texttt{\small 9}) la funzione \func{fputs} per
+scriverli su \file{stdout}.
-Queste due funzioni vengono usate per ottenere la socket pair associata ad un
-certo socket; la prima restituisce l'indirizzo locale, la seconda quello
-remoto.
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/ClientEcho.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice della prima versione della funzione \texttt{ClientEcho} per
+ la gestione del servizio \textit{echo}.}
+ \label{fig:TCP_client_echo_sub}
+\end{figure}
-\begin{prototype}{sys/socket.h}
-{int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+Quando si concluderà l'invio di dati mandando un end-of-file sullo standard
+input si avrà il ritorno di \func{fgets} con un puntatore nullo (si riveda
+quanto spiegato in \secref{sec:file_line_io}) e la conseguente uscita dal
+ciclo; al che la subroutine ritorna ed il nostro programma client termina.
+
+Si può effettuare una verifica del funzionamento del client abilitando il
+servizio \textit{echo} nella configurazione di \cmd{initd} sulla propria
+macchina ed usandolo direttamente verso di esso in locale, vedremo in
+dettaglio più avanti (in \secref{sec:TCP_echo_startup}) il funzionamento del
+programma, usato però con la nostra versione del server \textit{echo}, che
+illustriamo immediatamente.
+
+
+\subsection{Il server: prima versione}
+\label{sec:TCPsimp_server_main}
+
+La prima versione del server, contenuta nel file \file{TCP\_echod\_first.c}, è
+riportata in \figref{fig:TCP_echo_server_first_code}. Come abbiamo fatto per
+il client anche il server è stato diviso in un corpo principale, costituito
+dalla funzione \code{main}, che è molto simile a quello visto nel precedente
+esempio per il server del servizio \textit{daytime} di
+\secref{sec:TCP_daytime_cunc_server}, e da una funzione ausiliaria
+\code{ServEcho} che si cura della gestione del servizio.
+
+\begin{figure}[!htbp]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/TCP_echod_first.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice del corpo principale della prima versione del server
+ per il servizio \textit{echo}.}
+ \label{fig:TCP_echo_server_first_code}
+\end{figure}
- La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
- codici di errore restituiti in \var{errno} sono i seguenti:
- \begin{errlist}
- \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
- valido.
- \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
- \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
- eseguire l'operazione.
- \item \macro{EFAULT} l'argomento \var{name} punta al di fuori dello
- spazio di indirizzi del processo.
- \end{errlist}
-\end{prototype}
+In questo caso però, rispetto a quanto visto nell'esempio di
+\figref{fig:TCP_daytime_cunc_server_code} si è preferito scrivere il server
+curando maggiormente alcuni dettagli, per tenere conto anche di alcune
+esigenze generali (che non riguardano direttamente la rete), come la
+possibilità di lanciare il server anche in modalità interattiva e la cessione
+dei privilegi di amministratore non appena questi non sono più necessari.
+
+La sezione iniziale del programma (\texttt{\small 8--21}) è la stessa del
+server di \secref{sec:TCP_daytime_cunc_server}, ed ivi descritta in dettaglio:
+crea il socket, inizializza l'indirizzo e esegue \func{bind}; dato che
+quest'ultima funzione viene usata su una porta riservata, il server dovrà
+essere eseguito da un processo con i privilegi di amministratore, pena il
+fallimento della chiamata.
+
+Una volta eseguita la funzione \func{bind} però i privilegi di amministratore
+non sono più necessari, per questo è sempre opportuno rilasciarli, in modo da
+evitare problemi in caso di eventuali vulnerabilità del server. Per questo
+prima (\texttt{\small 22--26}) si esegue \func{setgid} per assegnare il
+processo ad un gruppo senza privilegi,\footnote{si è usato il valore 65534,
+ ovvero -1 per il formato \ctyp{short}, che di norma in tutte le
+ distribuzioni viene usato per identificare il gruppo \texttt{nogroup} e
+ l'utente \texttt{nobody}, usati appunto per eseguire programmi che non
+ richiedono nessun privilegio particolare.} e poi si ripete (\texttt{\small
+ 27--30}) l'operazione usando \func{setuid} per cambiare anche
+l'utente.\footnote{si tenga presente che l'ordine in cui si eseguono queste
+ due operazioni è importante, infatti solo avendo i privilegi di
+ amministratore si può cambiare il gruppo di un processo ad un'altro di cui
+ non si fa parte, per cui chiamare prima \func{setuid} farebbe fallire una
+ successiva chiamata a \func{setgid}. Inoltre si ricordi (si riveda quanto
+ esposto in \secref{sec:proc_perms}) che usando queste due funzioni il
+ rilascio dei privilegi è irreversibile.} Infine (\texttt{\small 30--36}),
+qualora sia impostata la variabile \var{demonize}, prima (\texttt{\small 31})
+si apre il sistema di logging per la stampa degli errori, e poi
+(\texttt{\small 32--35}) si invoca \func{daemon} per eseguire in background il
+processo come demone.
+
+A questo punto il programma riprende di nuovo lo schema già visto usato dal
+server per il servizio \textit{daytime}, con l'unica differenza della chiamata
+alla funzione \code{PrintErr}, riportata in \figref{fig:TCP_PrintErr}, al
+posto di \func{perror} per la stampa degli errori.
+
+Si inizia con il porre (\texttt{\small 37--41}) in ascolto il socket, e poi si
+esegue indefinitamente il ciclo principale (\texttt{\small 42--58}).
+All'interno di questo si ricevono (\texttt{\small 43--46}) le connessioni,
+creando (\texttt{\small 47--50}) un processo figlio per ciascuna di esse.
+Quest'ultimo (\texttt{\small 51--55}), chiuso (\texttt{\small 52}) il
+\textit{listening socket}, esegue (\texttt{\small 53}) la funzione di gestione
+del servizio \code{ServEcho}, ed al ritorno di questa (\texttt{\small 54})
+esce.
+
+Il padre invece si limita (\texttt{\small 56}) a chiudere il \textit{connected
+ socket} per ricominciare da capo il ciclo in attesa di nuove connessioni. In
+questo modo si ha un server concorrente. La terminazione del padre non è
+gestita esplicitamente, e deve essere effettuata inviando un segnale al
+processo.
+
+Avendo trattato direttamente la gestione del programma come demone, si è
+dovuto anche provvedere alla necessità di poter stampare eventuali messaggi di
+errore attraverso il sistema del \textit{syslog} trattato in
+\secref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando come
+\textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato in
+\figref{fig:TCP_PrintErr}.
+
+In essa ci si limita a controllare (\texttt{\small 2}) se è stato impostato
+(valore attivo per default) l'uso come demone, nel qual caso (\texttt{\small
+ 3}) si usa \func{syslog} (vedi \secref{sec:sess_daemon}) per stampare il
+messaggio di errore fornito come argomento sui log di sistema. Se invece si è
+in modalità interattiva (attivabile con l'opzione \texttt{-i}) si usa
+(\texttt{\small 5}) semplicemente la funzione \func{perror} per stampare sullo
+standard error.
-La funzione \func{getsockname} si usa tutte le volte che si vuole avere
-l'indirizzo locale di un socket; ad esempio può essere usata da un client (che
-usualmente non chiama \func{bind}) per ottenere numero IP e porta locale
-associati al socket restituito da una \func{connect}, o da un server che ha
-chiamato \func{bind} su un socket usando 0 come porta locale per ottenere il
-numero di porta effimera assegnato dal kernel.
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/PrintErr.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice della funzione \code{PrintErr} per la
+ generalizzazione della stampa degli errori sullo standard input o
+ attraverso il \texttt{syslog}.}
+ \label{fig:TCP_PrintErr}
+\end{figure}
-Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se
-chiamata dopo il completamento di una connessione sul socket restituito da
-\func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
-quella connessione.
+La gestione del servizio \textit{echo} viene effettuata interamente nella
+funzione \code{ServEcho}, il cui codice è mostrato in
+\figref{fig:TCP_ServEcho_first}, e la comunicazione viene gestita all'interno
+di un ciclo (\texttt{\small 6--13}). I dati inviati dal client vengono letti
+(\texttt{\small 6}) dal socket con una semplice \func{read}, di cui non si
+controlla lo stato di uscita, assumendo che ritorni solo in presenza di dati
+in arrivo. La riscrittura (\texttt{\small 7}) viene invece gestita dalla
+funzione \func{FullWrite} (descritta in \figref{fig:sock_FullWrite_code}) che
+si incarica di tenere conto automaticamente della possibilità che non tutti i
+dati di cui è richiesta la scrittura vengano trasmessi con una singola
+\func{write}.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/ServEcho_first.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice della prima versione della funzione \code{ServEcho} per la
+ gestione del servizio \textit{echo}.}
+ \label{fig:TCP_ServEcho_first}
+\end{figure}
-\begin{prototype}{sys/socket.h}
-{int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+In caso di errore di scrittura (si ricordi che \func{FullWrite} restituisce un
+valore nullo in caso di successo) si provvede (\texttt{\small 8--10}) a
+stampare il relativo messaggio con \func{PrintErr}. Quando il client chiude
+la connessione il ricevimento del FIN fa ritornare la \func{read} con un
+numero di byte letti pari a zero, il che causa l'uscita dal ciclo e il ritorno
+(\texttt{\small 12}) della funzione, che a sua volta causa la terminazione del
+processo figlio.
+
+
+\subsection{L'avvio e il funzionamento normale}
+\label{sec:TCP_echo_startup}
+
+Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà
+di considerare in dettaglio le varie problematiche che si possono incontrare
+nello scrivere un'applicazione di rete. Infatti attraverso l'esame delle sue
+modalità di funzionamento normali, all'avvio e alla terminazione, e di quello
+che avviene nelle varie situazioni limite, da una parte potremo approfondire
+la comprensione del protocollo TCP/IP e dall'altra ricavare le indicazioni
+necessarie per essere in grado di scrivere applicazioni robuste, in grado di
+gestire anche i casi limite.
+
+Il primo passo è compilare e lanciare il server (da root, per poter usare la
+porta 7 che è riservata), alla partenza esso eseguirà l'apertura passiva con
+la sequenza delle chiamate a \func{socket}, \func{bind}, \func{listen} e poi
+si bloccherà nella \func{accept}. A questo punto si potrà controllarne lo
+stato con \cmd{netstat}:
+\begin{verbatim}
+[piccardi@roke piccardi]$ netstat -at
+Active Internet connections (servers and established)
+Proto Recv-Q Send-Q Local Address Foreign Address State
+...
+tcp 0 0 *:echo *:* LISTEN
+...
+\end{verbatim} %$
+che ci mostra come il socket sia in ascolto sulla porta richiesta, accettando
+connessioni da qualunque indirizzo e da qualunque porta e su qualunque
+interfaccia locale.
+
+A questo punto si può lanciare il client, esso chiamerà \func{socket} e
+\func{connect}; una volta completato il three way handshake la connessione è
+stabilita; la \func{connect} ritornerà nel client\footnote{si noti che è
+ sempre la \func{connect} del client a ritornare per prima, in quanto
+ questo avviene alla ricezione del secondo segmento (l'ACK del server) del
+ three way handshake, la \func{accept} del server ritorna solo dopo
+ un altro mezzo RTT quando il terzo segmento (l'ACK del client) viene
+ ricevuto.} e la \func{accept} nel server, ed usando di nuovo
+\cmd{netstat} otterremmo che:
+\begin{verbatim}
+Active Internet connections (servers and established)
+Proto Recv-Q Send-Q Local Address Foreign Address State
+tcp 0 0 *:echo *:* LISTEN
+tcp 0 0 roke:echo gont:32981 ESTABLISHED
+\end{verbatim}
+mentre per quanto riguarda l'esecuzione dei programmi avremo che:
+\begin{itemize}
+\item il client chiama la funzione \code{ClientEcho} che si blocca sulla
+ \func{fgets} dato che non si è ancora scritto nulla sul terminale.
+\item il server eseguirà una \func{fork} facendo chiamare al processo figlio
+ la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read}
+ dal socket sul quale ancora non sono presenti dati.
+\item il processo padre del server chiamerà di nuovo \func{accept}
+ bloccandosi fino all'arrivo di un'altra connessione.
+\end{itemize}
+e se usiamo il comando \cmd{ps} per esaminare lo stato dei processi otterremo
+un risultato del tipo:
+\begin{verbatim}
+[piccardi@roke piccardi]$ ps ax
+ PID TTY STAT TIME COMMAND
+ ... ... ... ... ...
+ 2356 pts/0 S 0:00 ./echod
+ 2358 pts/1 S 0:00 ./echo 127.0.0.1
+ 2359 pts/0 S 0:00 ./echod
+\end{verbatim} %$
+(dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di
+tre processi, tutti in stato di \textit{sleep} (vedi
+\tabref{tab:proc_proc_states}).
+
+Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso
+niente fin tanto che non si prema il tasto di a capo (si ricordi quanto detto
+in \secref{sec:file_line_io} a proposito dell'I/O su terminale), solo allora
+\func{fgets} ritornerà ed il client scriverà quanto immesso sul socket, per
+poi passare a rileggere quanto gli viene inviato all'indietro dal server, che
+a sua volta sarà inviato sullo standard output, che nel caso ne provoca
+l'immediatamente stampa a video.
+
+
+\subsection{La conclusione normale}
+\label{sec:TCP_echo_conclusion}
+
+Tutto quello che scriveremo sul client sarà rimandato indietro dal server e
+ristampato a video fintanto che non concluderemo l'immissione dei dati; una
+sessione tipica sarà allora del tipo:
+\begin{verbatim}
+[piccardi@roke sources]$ ./echo 127.0.0.1
+Questa e` una prova
+Questa e` una prova
+Ho finito
+Ho finito
+\end{verbatim} %$
+che termineremo inviando un EOF dal terminale (usando la combinazione di tasti
+ctrl-D, che non compare a schermo); se eseguiamo un \cmd{netstat} a questo
+punto avremo:
+\begin{verbatim}
+[piccardi@roke piccardi]$ netstat -at
+tcp 0 0 *:echo *:* LISTEN
+tcp 0 0 localhost:33032 localhost:echo TIME_WAIT
+\end{verbatim} %$
+con il client che entra in \texttt{TIME\_WAIT}.
- La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
- codici di errore restituiti in \var{errno} sono i seguenti:
- \begin{errlist}
- \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
- valido.
- \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
- \item \macro{ENOTCONN} il socket non è connesso.
- \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
- eseguire l'operazione.
- \item \macro{EFAULT} l'argomento \var{name} punta al di fuori dello
- spazio di indirizzi del processo.
- \end{errlist}
-\end{prototype}
+Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
+terminazione normale della connessione, che ci servirà poi da riferimento
+quando affronteremo il comportamento in caso di conclusioni anomale:
+\begin{enumerate}
+\item inviando un carattere di EOF da terminale la \func{fgets} ritorna
+ restituendo un puntatore nullo che causa l'uscita dal ciclo di \code{while},
+ così la funzione \code{ClientEcho} ritorna.
+\item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e
+ come parte del processo terminazione tutti i file descriptor vengono chiusi
+ (si ricordi quanto detto in \secref{sec:proc_term_conclusion}); questo causa
+ la chiusura del socket di comunicazione; il client allora invierà un FIN al
+ server a cui questo risponderà con un ACK. A questo punto il client verrà a
+ trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato
+ \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in
+ \secref{sec:TCP_conn_term}).
+\item quando il server riceve il FIN la \func{read} del processo figlio che
+ gestisce la connessione ritorna restituendo 0 causando così l'uscita dal
+ ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio
+ termina chiamando \func{exit}.
+\item all'uscita del figlio tutti i file descriptor vengono chiusi, la
+ chiusura del socket connesso fa sì che venga effettuata la sequenza finale
+ di chiusura della connessione, viene emesso un FIN dal server che riceverà
+ un ACK dal client, a questo punto la connessione è conclusa e il client
+ resta nello stato \texttt{TIME\_WAIT}.
+\end{enumerate}
-La funzione \func{getpeername} si usa tutte le volte che si vuole avere
-l'indirizzo remoto di un socket.
-Ci si può chiedere a cosa serva questa funzione dato che dal lato client
-l'indirizzo remoto è sempre noto quando si esegue la \func{connect} mentre
-dal lato server si possono usare, come si è fatto nell'esempio precedente, i
-valori di ritorno di \func{accept}.
+\subsection{La gestione dei processi figli}
+\label{sec:TCP_child_hand}
-In generale però questa ultima possibilità è sempre possibile. In particolare
-questo avviene quando il server invece di far gestire la connessione
-direttamente a un processo figlio, come nell'esempio precedente, lancia un
-opportuno programma per ciascuna connessione usando \func{exec} (questa ad
-esempio è la modailità con cui opera il \textsl{super-server} \cmd{inetd}
-che gestisce tutta una serie di servizi lanciando per ogni connessione
-l'opportuno server).
+Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
+del procedimento di chiusura del processo figlio nel server (si veda quanto
+esaminato in \secref{sec:proc_termination}). In questo caso avremo l'invio del
+segnale \const{SIGCHLD} al padre, ma dato che non si è installato un
+gestore e che l'azione predefinita per questo segnale è quella di essere
+ignorato, non avendo predisposto la ricezione dello stato di terminazione,
+otterremo che il processo figlio entrerà nello stato di zombie\index{zombie}
+(si riveda quanto illustrato in \secref{sec:sig_sigchld}), come risulterà
+ripetendo il comando \cmd{ps}:
+\begin{verbatim}
+ 2356 pts/0 S 0:00 ./echod
+ 2359 pts/0 Z 0:00 [echod <defunct>]
+\end{verbatim}
-In questo caso benché il processo figlio abbia una immagine della memoria che
-è copia di quella del processo padre (e contiene quindi anche la struttura
-ritornata da \func{accept}), all'esecuzione di \func{exec} viene caricata
-in memoria l'immagine del programma eseguito che a questo punto perde ogni
-riferimento. Il socket descriptor però resta aperto. Allora se una opportuna
-convenzione è seguita per rendere noto al programma eseguito qual'è il socket
-connesso (\cmd{inetd} ad esempio fa sempre in modo che i file descriptor 0,
-1 e 2 corrispondano al socket connesso) quest'ultimo potrà usare la funzione
-\func{getpeername} per determinare l'indirizzo remoto del client.
+Dato che non è il caso di lasciare processi zombie\index{zombie}, occorrerà
+ricevere opportunamente lo stato di terminazione del processo (si veda
+\secref{sec:proc_wait}), cosa che faremo utilizzando \const{SIGCHLD} secondo
+quanto illustrato in \secref{sec:sig_sigchld}. Una prima modifica al nostro
+server è pertanto quella di inserire la gestione della terminazione dei
+processi figli attraverso l'uso di un gestore. Per questo useremo la funzione
+\code{Signal} (che abbiamo illustrato in \figref{fig:sig_Signal_code}), per
+installare il gestore che riceve i segnali dei processi figli terminati già
+visto in \figref{fig:sig_sigchld_handl}. Basterà allora aggiungere il
+seguente codice: \includecodesnip{listati/sigchildhand.c}
+\noindent
+all'esempio illustrato in \figref{fig:TCP_echo_server_first_code}.
+
+In questo modo però si introduce un altro problema. Si ricordi infatti che,
+come spiegato in \secref{sec:sig_gen_beha}, quando un programma si trova in
+stato di \texttt{sleep} durante l'esecuzione di una system call, questa viene
+interrotta alla ricezione di un segnale. Per questo motivo, alla fine
+dell'esecuzione del gestore del segnale, se questo ritorna, il programma
+riprenderà l'esecuzione ritornando dalla system call interrotta con un errore
+di \errcode{EINTR}.
+
+Vediamo allora cosa comporta tutto questo nel nostro caso: quando si chiude il
+client, il processo figlio che gestisce la connessione terminerà, ed il padre,
+per evitare la creazione di zombie, riceverà il segnale \const{SIGCHLD}
+eseguendo il relativo gestore. Al ritorno del gestore però l'esecuzione nel
+padre ripartirà subito con il ritorno della funzione \func{accept} (a meno di
+un caso fortuito in cui il segnale arriva durante l'esecuzione del programma
+in risposta ad una connessione) con un errore di \errcode{EINTR}. Non avendo
+previsto questa eventualità il programma considera questo un errore fatale
+terminando a sua volta con un messaggio del tipo:
+\begin{verbatim}
+[root@gont sources]# ./echod -i
+accept error: Interrupted system call
+\end{verbatim}%#
+
+Come accennato in \secref{sec:sig_gen_beha} le conseguenze di questo
+comportamento delle system call possono essere superate in due modi diversi,
+il più semplice è quello di modificare il codice di \func{Signal} per
+richiedere il riavvio automatico delle system call interrotte secondo la
+semantica di BSD, usando l'opzione \const{SA\_RESTART} di \func{sigaction};
+rispetto a quanto visto in \figref{fig:sig_Signal_code}. Definiremo allora la
+nuova funzione \func{SignalRestart}\footnote{anche questa è definita, insieme
+ alle altre funzioni riguardanti la gestione dei segnali, nel file
+ \file{SigHand.c}, il cui contento completo può essere trovato negli esempi
+ allegati.} come mostrato in \figref{fig:sig_SignalRestart_code}, ed
+installeremo il gestore usando quest'ultima.
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/SignalRestart.c}
+ \end{minipage}
+ \normalsize
+ \caption{La funzione \funcd{SignalRestart}, che installa un gestore di
+ segnali in semantica BSD per il riavvio automatico delle system call
+ interrotte.}
+ \label{fig:sig_SignalRestart_code}
+\end{figure}
+
+Come si può notare questa funzione è identica alla precedente \func{Signal},
+illustrata in \figref{fig:sig_Signal_code}, solo che in questo caso invece di
+inizializzare a zero il campo \var{sa\_flags} di \struct{sigaction}, lo si
+inizializza (\texttt{\small 5}) al valore \const{SA\_RESTART}. Usando questa
+funzione al posto di \func{Signal} nel server non è necessaria nessuna altra
+modifica: le system call interrotte saranno automaticamente riavviate, e
+l'errore \errcode{EINTR} non si manifesterà più.
+
+La seconda soluzione è più invasiva e richiede di controllare tutte le volte
+l'errore restituito dalle varie system call, ripetendo la chiamata qualora
+questo corrisponda ad \errcode{EINTR}. Questa soluzione ha però il pregio
+della portabilità, infatti lo standard POSIX dice che la funzionalità di
+riavvio automatico delle system call, fornita da \const{SA\_RESTART}, è
+opzionale, per cui non è detto che essa sia disponibile su qualunque sistema.
+Inoltre in certi casi,\footnote{Stevens in \cite{UNP1} accenna che la maggior
+ parte degli Unix derivati da BSD non fanno ripartire \func{select}; altri
+ non riavviano neanche \func{accept} e \func{recvfrom}, cosa che invece nel
+ caso di Linux viene sempre fatta.} anche quando questa è presente, non è
+detto possa essere usata con \func{accept}.
+
+
+La portabilità nella gestione dei segnali però viene al costo di una
+riscrittura parziale del server, la nuova versione di questo, in cui si sono
+introdotte una serie di nuove opzioni che ci saranno utili per il debug, è
+mostrata in \figref{fig:TCP_echo_server_code_second}, dove si sono riportate
+la sezioni di codice modificate nella seconda versione del programma, il
+sorgente completo di quest'ultimo si trova nel file
+\file{TCP\_echod\_second.c} dei sorgenti allegati alla guida.
+
+La prima modifica effettuata è stata quella di introdurre una nuova opzione a
+riga di comando, \texttt{-c}, che permette di richiedere il comportamento
+compatibile nella gestione di \const{SIGCHLD} al posto della semantica BSD
+impostando la variabile \var{compat} ad un valore non nullo. Questa è
+preimpostata al valore nullo, cosicché se non si usa questa opzione il
+comportamento di default del server è di usare la semantica BSD.
+
+Una seconda opzione aggiunta è quella di inserire un tempo di attesa fisso
+specificato in secondi fra il ritorno della funzione \func{listen} e la
+chiamata di \func{accept}, specificabile con l'opzione \texttt{-w}, che
+permette di impostare la variabile \var{waiting}. Infine si è introdotta una
+opzione \texttt{-d} per abilitare il debugging che imposta ad un valore non
+nullo la variabile \var{debugging}. Al solito si è omessa da
+\figref{fig:TCP_echo_server_code_second} la sezione di codice relativa alla
+gestione di tutte queste opzioni, che può essere trovata nel sorgente del
+programma.
-Infine è da chiarire (si legga la man page) che come per \func{accept} il
-terzo parametro che è specificato dallo standard POSIX 1003.1g come di tipo
-\type{socklen\_t *} in realtà deve sempre corrispondere ad un \type{int *}
-come prima dello standard perché tutte le implementazioni dei socket BSD fanno
-questa assunzione.
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{15.6cm}
+ \includecodesample{listati/TCP_echod_second.c}
+ \end{minipage}
+ \normalsize
+ \caption{La sezione nel codice della seconda versione del server
+ per il servizio \textit{echo} modificata per tener conto dell'interruzione
+ delle system call.}
+ \label{fig:TCP_echo_server_code_second}
+\end{figure}
+Vediamo allora come è cambiato il nostro server; una volta definite le
+variabili e trattate le opzioni il primo passo (\texttt{\small 9--13}) è
+verificare la semantica scelta per la gestione di \const{SIGCHLD}, a seconda
+del valore di \var{compat} (\texttt{\small 9}) si installa il gestore con la
+funzione \func{Signal} (\texttt{\small 10}) o con \texttt{SignalRestart}
+(\texttt{\small 12}), essendo quest'ultimo il valore di default.
+
+Tutta la sezione seguente, che crea il socket, cede i privilegi di
+amministratore ed eventualmente lancia il programma come demone, è rimasta
+invariata e pertanto è stata omessa in
+\figref{fig:TCP_echo_server_code_second}; l'unica modifica effettuata prima
+dell'entrata nel ciclo principale è stata quella di aver introdotto, subito
+dopo la chiamata (\texttt{\small 17--20}) alla funzione \func{listen}, una
+eventuale pausa con una condizione (\texttt{\small 21}) sulla variabile
+\var{waiting}, che viene inizializzata, con l'opzione \code{-w Nsec}, al
+numero di secondi da aspettare (il valore preimpostato è nullo).
+
+Si è potuto lasciare inalterata tutta la sezione di creazione del socket
+perché nel server l'unica chiamata ad una system call critica, che può essere
+interrotta dall'arrivo di \const{SIGCHLD}, è quella ad \func{accept}, che è
+l'unica funzione che può mettere il processo padre in stato di sleep nel
+periodo in cui un figlio può terminare; si noti infatti come le altre
+\textit{slow system call}\footnote{si ricordi la distinzione fatta in
+ \secref{sec:sig_gen_beha}.} o sono chiamate prima di entrare nel ciclo
+principale, quando ancora non esistono processi figli, o sono chiamate dai
+figli stessi e non risentono di \const{SIGCHLD}.
+
+Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small
+ 23--42}), rispetto precedente versione di \figref{fig:TCP_ServEcho_first}, è
+nella sezione (\texttt{\small 26--30}) in cui si effettua la chiamata di
+\func{accept}. Quest'ultima viene effettuata (\texttt{\small 26--27})
+all'interno di un ciclo di \code{while}\footnote{la sintassi del C relativa a
+ questo ciclo può non essere del tutto chiara. In questo caso infatti si è
+ usato un ciclo vuoto che non esegue nessuna istruzione, in questo modo
+ quello che viene ripetuto con il ciclo è soltanto il codice che esprime la
+ condizione all'interno del \code{while}.} che la ripete indefinitamente
+qualora in caso di errore il valore di \var{errno} sia \errcode{EINTR}. Negli
+altri casi si esce in caso di errore effettivo (\texttt{\small 27--29}),
+altrimenti il programma prosegue.
+
+Si noti che in questa nuova versione si è aggiunta una ulteriore sezione
+(\texttt{\small 31--39}) di aiuto per il debug del programma, che eseguita con
+un controllo (\texttt{\small 31}) sul valore della variabile \var{debugging}
+impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come
+preimpostato, non accade nulla. altrimenti (\texttt{\small 32}) l'indirizzo
+ricevuto da \var{accept} viene convertito in una stringa che poi
+(\texttt{\small 33--38}) viene opportunamente stampata o sullo schermo o nei
+log.
+
+
+
+
+\section{I vari scenari critici}
+\label{sec:TCP_echo_critical}
+
+Con le modifiche viste in \secref{sec:TCP_child_hand} il nostro esempio
+diventa in grado di affrontare la gestione ordinaria delle connessioni, ma un
+server di rete deve tenere conto che, al contrario di quanto avviene per i
+server che operano nei confronti di processi presenti sulla stessa macchina,
+la rete è di sua natura inaffidabile, per cui è necessario essere in grado di
+gestire tutta una serie di situazioni critiche che non esistono per i processi
+locali.
+
+
+\subsection{La terminazione precoce della connessione}
+\label{sec:TCP_conn_early_abort}
+
+La prima situazione critica è quella della terminazione precoce, causata da un
+qualche errore sulla rete, della connessione effettuata da un client. Come
+accennato in \secref{sec:TCP_func_accept} la funzione \func{accept} riporta
+tutti gli eventuali errori di rete pendenti su una connessione sul
+\textit{connected socket}. Di norma questo non è un problema, in quanto non
+appena completata la connessione, \func{accept} ritorna e l'errore sarà
+rilevato in seguito, dal processo che gestisce la connessione, alla prima
+chiamata di una funzione che opera sul socket.
+
+È però possibile, dal punto di vista teorico, incorrere anche in uno scenario
+del tipo di quello mostrato in \figref{fig:TCP_early_abort}, in cui la
+connessione viene abortita sul lato client per un qualche errore di rete con
+l'invio di un segmento RST, prima che nel server sia stata chiamata la
+funzione \func{accept}.
+
+\begin{figure}[htb]
+ \centering
+ \includegraphics[width=10cm]{img/tcp_client_early_abort}
+ \caption{Un possibile caso di terminazione precoce della connessione.}
+ \label{fig:TCP_early_abort}
+\end{figure}
+Benché questo non sia un fatto comune, un evento simile può essere osservato
+con dei server molto occupati. In tal caso, con una struttura del server
+simile a quella del nostro esempio, in cui la gestione delle singole
+connessioni è demandata a processi figli, può accadere che il three way
+handshake venga completato e la relativa connessione abortita subito dopo,
+prima che il padre, per via del carico della macchina, abbia fatto in tempo ad
+eseguire la chiamata ad \func{accept}. Di nuovo si ha una situazione analoga
+a quella illustrata in \figref{fig:TCP_early_abort}, in cui la connessione
+viene stabilita, ma subito dopo si ha una condizione di errore che la chiude
+prima che essa sia stata accettata dal programma.
+
+Questo significa che, oltre alla interruzione da parte di un segnale, che
+abbiamo trattato in \secref{sec:TCP_child_hand} nel caso particolare di
+\const{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
+\func{accept}, che come nel caso precedente, necessitano semplicemente la
+ripetizione della chiamata senza che si debba uscire dal programma. In questo
+caso anche la versione modificata del nostro server non sarebbe adatta, in
+quanto uno di questi errori causerebbe la terminazione dello stesso. In Linux
+i possibili errori di rete non fatali, riportati sul socket connesso al
+ritorno di \func{accept}, sono \errcode{ENETDOWN}, \errcode{EPROTO},
+\errcode{ENOPROTOOPT}, \errcode{EHOSTDOWN}, \errcode{ENONET},
+\errcode{EHOSTUNREACH}, \errcode{EOPNOTSUPP} e \errcode{ENETUNREACH}.
+
+Si tenga presente che questo tipo di terminazione non è riproducibile
+terminando il client prima della chiamata ad \func{accept}, come si potrebbe
+fare usando l'opzione \texttt{-w} per introdurre una pausa dopo il lancio del
+demone, in modo da poter avere il tempo per lanciare e terminare una
+connessione usando il programma client. In tal caso infatti, alla terminazione
+del client, il socket associato alla connessione viene semplicemente chiuso,
+attraverso la sequenza vista in \secref{sec:TCP_conn_term}, per cui la
+\func{accept} ritornerà senza errori, e si avrà semplicemente un end-of-file
+al primo accesso al socket. Nel caso di Linux inoltre, anche qualora si
+modifichi il client per fargli gestire l'invio di un segmento di RST alla
+chiusura dal socket (come suggerito da Stevens in \cite{UNP1}), non si ha
+nessun errore al ritorno di \funcd{accept} quanto un errore di
+\errcode{ECONNRESET} al primo tentativo di accesso al socket.
+
+
+
+\subsection{Il crollo del server}
+\label{sec:TCP_server_crash}
+
+Un secondo caso critico è quello in cui si ha il crollo del server. In tal
+caso si suppone che il processo del server termini per un errore fatale, cosa
+che potremo simulare inviandogli un segnale di terminazione. La conclusione
+del processo comporta la chiusura di tutti i file aperti, compresi tutti i
+socket relativi a connessioni stabilite; questo significa che al momento del
+crollo del servizio il client riceverà un FIN dal server in corrispondenza
+della chiusura del socket.
+
+
+
+
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: "gapil"
+%%% End:
projects / gapil.git / blobdiff