%% tcpsock.tex
%%
-%% Copyright (C) 2000-2005 Simone Piccardi. Permission is granted to
+%% Copyright (C) 2000-2016 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 "Un preambolo",
%% license is included in the section entitled "GNU Free Documentation
%% License".
%%
+
\chapter{I socket TCP}
\label{cha:TCP_socket}
descrizione delle principali caratteristiche del funzionamento di una
connessione TCP; vedremo poi le varie funzioni che servono alla creazione di
una connessione fra client e server, fornendo alcuni esempi elementari, e
-finiremo prendendo in esame l'uso dell'I/O multiplexing.
+finiremo prendendo in esame l'uso dell'\textit{I/O multiplexing}.
\section{Il funzionamento di una connessione TCP}
\label{sec:TCP_connession}
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
+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.
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.
+cioè una forma di canale di comunicazione che stabilisce una connessione
+stabile fra due macchine in rete, 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:TCP_conn_cre}
\itindbeg{three~way~handshake}
-Il processo che porta a creare una connessione TCP è chiamato \textit{three
- 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 sez.~\ref{sec:tcp_protocol}).} di dati che vengono
-scambiati) che porta alla creazione di una connessione è la seguente:
+
+Il processo che porta a creare una connessione TCP viene chiamato
+\textit{three way handshake}; la successione tipica degli eventi (e dei
+\textsl{segmenti}\footnote{si ricordi che il \textsl{segmento} è l'unità
+ elementare di dati trasmessa dal protocollo TCP al livello successivo; tutti
+ i segmenti hanno un'intestazione che contiene le informazioni che servono
+ allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
+ che realizza il protocollo) per effettuare 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 sez.~\ref{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;
\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, 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.
+ contiene solo le intestazioni di 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
+\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 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 il ricevuto del SYN del
- server inviando un ACK. Alla ricezione di quest'ultimo la funzione
- \func{accept} del server ritorna e la connessione è stabilita.
+\item Una volta che il client ha ricevuto l'\textit{acknowledge} dal server la
+ funzione \func{connect} ritorna, l'ultimo passo è dare il ricevuto del SYN
+ del server inviando un ACK. Alla ricezione di quest'ultimo la funzione
+ \func{accept} del server ritorna e la connessione è stabilita.
\end{enumerate}
Il procedimento viene chiamato \textit{three way handshake} dato che per
-realizzarlo devono essere scambiati tre segmenti. In fig.~\ref{fig:TCP_TWH}
-si è rappresentata graficamente la sequenza di scambio dei segmenti che
+realizzarlo devono essere scambiati tre segmenti. In fig.~\ref{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 \func{socket} può essere considerata
-% l'equivalente di avere un telefono. La funzione \func{bind} è analoga al
-% dire alle altre persone qual è il proprio numero di telefono perché possano
-% chiamare. La funzione \func{listen} è accendere il campanello del telefono
+% Una analogia citata da R. Stevens per la connessione TCP è quella con il
+% sistema del telefono. La funzione \func{socket} può essere considerata
+% l'equivalente di avere un telefono. La funzione \func{bind} è analoga al
+% dire alle altre persone qual è il proprio numero di telefono perché possano
+% chiamare. La funzione \func{listen} è accendere il campanello del telefono
% per sentire le chiamate in arrivo. La funzione \func{connect} richiede di
-% conoscere il numero di chi si vuole chiamare. La funzione \func{accept} è
+% conoscere il numero di chi si vuole chiamare. La funzione \func{accept} è
% quando si risponde al telefono.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=10cm]{img/three_way_handshake}
+\begin{figure}[!htb]
+ \centering \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 fig.~\ref{fig:TCP_TWH}): per gestire una connessione affidabile
+\index{numeri~di~sequenza|(}
+
+Si è accennato in precedenza ai \textsl{numeri di sequenza}, che sono anche
+riportati in fig.~\ref{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
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 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 fig.~\ref{fig:TCP_close}) per l'acknowledgement di un FIN.
-
+all'inizio della connessione e trasmesso con il SYN;
+l'\textit{acknowledgement} di 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 \textit{acknowledge} è sempre pari al numero di sequenza iniziale
+incrementato di uno; lo stesso varrà anche (vedi fig.~\ref{fig:TCP_close}) per
+l'\textit{acknowledgement} di un segmento FIN.
+
+\index{numeri~di~sequenza|)}
\itindend{three~way~handshake}
\subsection{Le opzioni TCP.}
\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
-dati) che servono a comunicare all'altro capo una serie di parametri utili a
-regolare la connessione. Normalmente vengono usate le seguenti opzioni:
+Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP,
+le cosiddette \textit{TCP options}, da non confondere con le opzioni dei
+socket TCP che tratteremo in sez.~\ref{sec:sock_tcp_udp_options}; in questo
+caso infatti si tratta delle opzioni che vengono trasmesse come parte di un
+pacchetto TCP, e non delle funzioni che consentono di impostare i relativi
+valori. Queste opzioni vengono inserite fra l'intestazione ed i dati, e
+servono a comunicare all'altro capo una serie di parametri utili a regolare la
+connessione. Normalmente vengono usate le seguenti opzioni:
\begin{itemize}
-\item \textit{MSS option}, dove MMS sta per \textit{maximum segment size}, con
- questa opzione ciascun capo della connessione annuncia all'altro il massimo
- ammontare di dati che vorrebbe accettare per ciascun segmento nella
- connessione corrente. È possibile leggere e scrivere questo valore
- attraverso l'opzione del socket \const{TCP\_MAXSEG}.
+\item \textit{MSS option}, con questa opzione ciascun capo della connessione
+ annuncia all'altro il massimo ammontare di dati (MMS sta appunto per
+ \textit{Maximum Segment Size}, vedi sez.~\ref{sec:tcp_protocol}) che
+ vorrebbe accettare per ciascun segmento nella connessione corrente. È
+ possibile leggere e scrivere questo valore attraverso l'opzione del socket
+ \const{TCP\_MAXSEG} (vedi sez.~\ref{sec:sock_tcp_udp_options}).
-\item \textit{window scale
- option}, %come spiegato in sez.~\ref{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 byte;\footnote{ Linux usa come massimo 32767
- per evitare problemi con alcune implementazioni che usano l'aritmetica con
- segno per implementare lo stack TCP.} ma alcuni tipi di connessione come
- quelle ad alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi
- ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra
- più grande per poter ottenere il massimo dalla trasmissione, per questo
- esiste questa opzione che indica un fattore di scala da applicare al valore
- della finestra annunciata\footnote{essendo una nuova opzione per garantire
- la compatibilità con delle vecchie implementazioni del protocollo la
- procedura che la attiva prevede come negoziazione che l'altro capo della
- connessione riconosca esplicitamente l'opzione inserendola anche lui nel
- suo SYN di risposta dell'apertura della connessione.} per la connessione
- corrente (espresso come numero di bit cui spostare a sinistra il valore
- della finestra annunciata inserito nel pacchetto).
-
-\item \textit{timestamp option}, è anche questa una nuova opzione necessaria
- per le connessioni ad alta velocità per evitare possibili corruzioni di dati
- dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come
- la precedente.
+\item \textit{window scale option}, il protocollo TCP realizza il controllo di
+ flusso attraverso una \textit{advertised window} (la ``\textsl{finestra
+ annunciata}'', vedi sez.~\ref{sec:tcp_protocol}) con la quale ciascun capo
+ della comunicazione dichiara quanto spazio disponibile ha in memoria per i
+ dati. Questo è un numero a 16 bit dell'header, che così può indicare un
+ massimo di 65535 byte\footnote{in Linux il massimo è 32767 per evitare
+ problemi con alcune realizzazione dello \textit{stack TCP} che usano
+ l'aritmetica con segno.} 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 un'altra opzione che indica un fattore di scala da
+ applicare al valore della finestra annunciata per la connessione corrente
+ (espresso come numero di bit cui spostare a sinistra il valore della
+ finestra annunciata inserito nel pacchetto). Essendo una nuova opzione per
+ garantire la compatibilità con delle vecchie realizzazione 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.
+
+ Con Linux è possibile indicare al kernel di far negoziare il fattore di
+ scala in fase di creazione di una connessione tramite la \textit{sysctl}
+ \texttt{tcp\_window\_scaling} (vedi sez.~\ref{sec:sock_ipv4_sysctl}). Per
+ poter usare questa funzionalità è comunque necessario ampliare le dimensioni
+ dei buffer di ricezione e spedizione, cosa che può essere fatta sia a
+ livello di sistema con le opportune \textit{sysctl} (vedi
+ sez.~\ref{sec:sock_ipv4_sysctl}) che a livello di singoli socket con le
+ relative opzioni (vedi sez.~\ref{sec:sock_tcp_udp_options}).
+
+\item \textit{timestamp option}, è anche questa una nuova opzione necessaria
+ per le connessioni ad alta velocità per evitare possibili corruzioni di dati
+ dovute a pacchetti perduti che riappaiono; anche questa viene negoziata
+ all'inizio della connessione come la precedente.
\end{itemize}
-La MSS è generalmente supportata da quasi tutte le implementazioni del
-protocollo, le ultime due opzioni (trattate
+La \textit{MSS option} è generalmente supportata da quasi tutte le
+realizzazioni del 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.
+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 queste opzioni
+aggiuntive.
+
\subsection{La terminazione della connessione}
\label{sec:TCP_conn_term}
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:
+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
- serve ad indicare 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 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
- riceveranno altri dati sulla connessione.
+\item L'altro capo della connessione riceve il segmento 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
+ \textit{end-of-file} sulla lettura: questo perché il ricevimento di un
+ segmento FIN significa che non si riceveranno altri dati sulla connessione.
-\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 Una volta rilevata l'\textit{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.
+\item L'altro capo della connessione riceverà il segmento FIN conclusivo e
+ risponderà con un ACK.
\end{enumerate}
Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
-normalmente i segmenti scambiati sono quattro. Questo non è vero sempre
-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
-fig.~\ref{fig:TCP_close} si è rappresentato graficamente lo sequenza di
+normalmente i segmenti scambiati sono quattro. Questo non è vero sempre
+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. 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. In
+fig.~\ref{fig:TCP_close} si è rappresentata graficamente la sequenza di
scambio dei segmenti che conclude la connessione.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=10cm]{img/tcp_close}
+\begin{figure}[!htb]
+ \centering \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
+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
+è 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 sez.~\ref{sec:TCP_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 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.
+La emissione del segmento FIN avviene quando il socket viene chiuso, questo
+però non 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 occorre sottolineare che, benché nella figura (e nell'esempio che
-vedremo più avanti in sez.~\ref{sec:TCP_echo}) sia stato il client ad eseguire
-la chiusura attiva, nella realtà questa può essere eseguita da uno qualunque
+Infine occorre sottolineare che, benché nella figura (e nell'esempio che
+vedremo più avanti in sez.~\ref{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
-fig.~\ref{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.
+fig.~\ref{fig:TCP_daytime_iter_server_code}), e che anche se il caso più
+comune resta quello del client, ci sono alcuni servizi, il più noto dei quali
+è l'HTTP 1.0 (con le versioni successive il default è cambiato) per i quali è
+il server ad effettuare la chiusura attiva.
\subsection{Un esempio di connessione}
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 sez.~\ref{sec:TCP_states} vedremo con
-maggiori dettagli che una connessione può assumere vari stati, che ne
+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}.
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
+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
diventa \texttt{SYN\_SENT}; quando il TCP riceve la risposta del SYN$+$ACK
-emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
+emette un ACK e passa allo stato \texttt{ESTABLISHED}; questo è lo stato
finale in cui avviene la gran parte del trasferimento dei dati.
Dal lato server in genere invece il passaggio che si opera con l'apertura
-passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
+passiva è quello di portare il socket dallo stato \texttt{CLOSED} allo
stato \texttt{LISTEN} in cui vengono accettate le connessioni.
-Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
+Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione
chiama la funzione \func{close} prima di aver ricevuto un
-\textit{end-of-file} (chiusura attiva) la transizione è verso lo stato
+\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{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato
\texttt{CLOSE\_WAIT}.
-In fig.~\ref{fig:TCP_conn_example} è riportato lo schema dello scambio dei
+In fig.~\ref{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}
+\begin{figure}[!htb]
+ \centering \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 con Linux per IPv4 su Ethernet, il server risponde con lo stesso
-valore (ma potrebbe essere anche un valore diverso).
+La connessione viene iniziata dal client che annuncia una \textit{Maximum
+ Segment Size} 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
+Una volta che la connessione è stabilita il client scrive al server una
+richiesta (che assumiamo stare in un singolo segmento, cioè essere minore dei
1460 byte annunciati dal server), quest'ultimo riceve la richiesta e
restituisce una risposta (che di nuovo supponiamo stare in un singolo
-segmento). Si noti che l'acknowledge della richiesta è mandato insieme alla
-risposta: questo viene chiamato \textit{piggybacking} ed avviene tutte le
-volte che 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.
+segmento). Si noti che l'\textit{acknowledge} della richiesta è mandato
+insieme alla risposta: questo viene chiamato \textit{piggybacking} ed avviene
+tutte le volte 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 sez.~\ref{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
-fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
-costo che occorre pagare per avere l'affidabilità garantita dal TCP, se si
+È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
+e uno di risposta) TCP necessiti di ulteriori otto segmenti, se invece si
+fosse usato UDP sarebbero stati sufficienti due soli pacchetti. Questo è il
+costo che occorre pagare per avere l'affidabilità garantita da TCP, se si
fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di
dettagli (come la verifica della ricezione dei pacchetti) dal livello del
trasporto all'interno dell'applicazione.
-Quello che è bene sempre tenere presente è allora quali sono le esigenze che
-si hanno in una applicazione di rete, perché non è detto che TCP sia la
+Quello che è bene sempre tenere presente è allora quali sono le esigenze che
+si hanno in una applicazione di rete, perché non è detto che TCP sia la
miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati
-già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
-per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
-specifico le sue caratteristiche di velocità e compattezza nello scambio dei
+già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo)
+per questo esistono applicazioni che usano UDP e lo fanno perché nel caso
+specifico le sue caratteristiche di velocità e compattezza nello scambio dei
dati rispondono meglio alle esigenze che devono essere affrontate.
+
\subsection{Lo stato \texttt{TIME\_WAIT}}
\label{sec:TCP_time_wait}
-Come riportato da Stevens in \cite{UNP1} lo stato \texttt{TIME\_WAIT} è
-probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
+Come riportato da Stevens in \cite{UNP1} lo stato \texttt{TIME\_WAIT} è
+probabilmente uno degli aspetti meno compresi del protocollo TCP, è infatti
comune trovare domande su come sia possibile evitare che un'applicazione resti
-in questo stato lasciando attiva una connessione ormai conclusa; la risposta è
+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 fig.~\ref{fig:TCP_conn_example})
-\texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che
+\itindex{Maximum~Segment~Lifetime}
+Come si è visto nell'esempio precedente (vedi fig.~\ref{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 sez.~\ref{sec:ip_protocol}), 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
+essere due volte la \textit{Maximum Segment Lifetime} (da qui in avanti
+abbreviata in MSL).
+
+La MSL è la stima del massimo periodo di tempo in secondi 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'intestazione di IP (per maggiori dettagli vedi
+sez.~\ref{sec:ip_protocol}), 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, sulla
+sua base si può stimare che un pacchetto IP non possa restare nella rete per
+più un certo numero di secondi, che costituisce la \textit{Maximum Segment
+ Lifetime}.
+
+Ogni realizzazione del TCP deve scegliere un valore per la MSL;
+l'\href{http://www.ietf.org/rfc/rfc1122.txt}{RFC~1122} raccomanda 2 minuti,
+mentre Linux usa 30 secondi, questo comporta una durata dello stato
+\texttt{TIME\_WAIT} che a seconda delle realizzazioni 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
+\begin{enumerate*}
+\item effettuare in maniera affidabile la terminazione della connessione
in entrambe le direzioni.
\item consentire l'eliminazione dei segmenti duplicati dalla rete.
-\end{enumerate}
+\end{enumerate*}
-Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
-riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
-capisce il perché della scelta di un tempo pari al doppio della MSL come
+Il punto è che entrambe le ragioni sono importanti, anche se spesso si fa
+riferimento solo alla prima; ma è solo se si tiene conto della seconda che si
+capisce il perché della scelta di un tempo pari al doppio della MSL come
durata di questo stato.
-Il primo dei due motivi precedenti si può capire tornando a
+Il primo dei due motivi precedenti si può capire tornando a
fig.~\ref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza
(quello del capo che ha eseguito la chiusura attiva) venga perso, chi esegue
-la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per
+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
+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
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 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 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
+Il caso più comune in cui questo avviene è quello di anomalie
+nell'instradamento; può accadere cioè che un router smetta di funzionare o che
una connessione fra due router si interrompa. In questo caso i protocolli di
instradamento dei pacchetti possono impiegare diverso tempo (anche dell'ordine
dei minuti) prima di trovare e stabilire un percorso alternativo per i
pacchetti. Nel frattempo possono accadere casi in cui un router manda i
pacchetti verso un altro e quest'ultimo li rispedisce indietro, o li manda ad
-un terzo router che li rispedisce al primo, si creano cioè dei circoli (i
+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 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.
+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
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.
+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
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
+Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere
creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT}
per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che
tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che
\subsection{I numeri di porta}
\label{sec:TCP_port_num}
-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.
+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
+\textsl{numeri di porta}, che fanno parte, come si può vedere in
sez.~\ref{sec:sock_sa_ipv4} e sez.~\ref{sec:sock_sa_ipv6} pure delle strutture
degli indirizzi del socket.
-Quando un client contatta un server deve poter identificare con quale dei vari
-possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo
-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 SSH) effettuati da appositi server che rispondono alle connessioni
-verso tali porte.
+Quando un client contatta una macchina server deve poter identificare con
+quale dei vari possibili programmi 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 SSH) effettuati da appositi
+programmi server che rispondono alle connessioni verso tali porte.
-D'altra parte un client non ha necessità di usare un numero di porta
-specifico, per cui in genere vengono usate le cosiddette \textsl{porte
- effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
+D'altra parte un client non ha necessità di usare dalla sua parte un numero di
+porta specifico, per cui in genere vengono usate le cosiddette \textsl{porte
+ effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato
nessun servizio noto e che vengono assegnate automaticamente dal kernel alla
creazione della connessione. Queste sono dette effimere in quanto vengono
usate solo per la durata della connessione, e l'unico requisito che deve
-essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
+essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca.
-La lista delle porte conosciute è definita
+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
-\href{ftp://ftp.isi.edu/in-notes/iana/assignements/port-number}
-{\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:
+Internet (una versione aggiornata si può trovare all'indirizzo
+\url{http://www.iana.org/assignments/port-numbers}); inoltre in un sistema
+unix-like un analogo elenco viene mantenuto nel file \conffile{/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 note}. 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
+ assegnate dalla IANA. Se è possibile la stessa porta è assegnata allo stesso
+ servizio sia su UDP che su TCP (ad esempio la porta 22 è assegnata a SSH su
entrambi i protocolli, anche se viene usata solo dal TCP).
\item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non
- sono controllate dalla IANA, che però registra ed elenca chi usa queste
+ sono controllate dalla IANA, che però registra ed elenca chi usa queste
porte come servizio agli utenti. Come per le precedenti si assegna una porta
- ad un servizio sia per TCP che UDP anche se poi il servizio è implementato
- solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063
- anche se il protocollo è implementato solo tramite TCP.
+ ad un servizio sia per TCP che UDP anche se poi il servizio è effettuato
+ solo su TCP. Ad esempio \textit{X Window} usa le porte TCP e UDP dal 6000 al
+ 6063 anche se il protocollo viene usato solo con TCP.
\item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a
65535. La IANA non dice nulla riguardo a queste porte che pertanto
sono i candidati naturali ad essere usate come porte effimere.
\end{enumerate*}
-In realtà rispetto a quanto indicato
+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
fig.~\ref{fig:TCP_port_alloc} sono riportate quelle di BSD e Linux.
\begin{figure}[!htb]
- \centering
- \includegraphics[width=13cm]{img/port_alloc}
+ \centering \includegraphics[width=13cm]{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
-\textsl{porte note}). La loro caratteristica è che possono essere assegnate a
-un socket solo da un processo con i privilegi di amministratore, per far sì
+\textsl{porte note}. La loro caratteristica è che possono essere assegnate a
+un socket solo da un processo con i privilegi di amministratore, per far sì
che solo l'amministratore possa allocare queste porte per far partire i
relativi servizi.
-Le \textsl{glibc} definiscono (in \texttt{netinet/in.h})
-\const{IPPORT\_RESERVED} e \const{IPPORT\_USERRESERVED}, in cui la prima (che
-vale 1024) indica il limite superiore delle porte riservate, e la seconda (che
-vale 5000) il limite inferiore delle porte a disposizione degli utenti. La
-convenzione vorrebbe che le porte \textsl{effimere} siano allocate fra questi
-due valori. Nel caso di Linux questo è vero solo in uno dei due casi di
+Le \textsl{glibc} definiscono in \headfile{netinet/in.h} le costanti
+\constd{IPPORT\_RESERVED} e \constd{IPPORT\_USERRESERVED}, in cui la prima
+(che vale 1024) indica il limite superiore delle porte riservate, e la seconda
+(che vale 5000) il limite inferiore delle porte a disposizione degli utenti.
+La convenzione vorrebbe che le porte \textsl{effimere} siano allocate fra
+questi due valori. Nel caso di Linux questo è vero solo in uno dei due casi di
fig.~\ref{fig:TCP_port_alloc}, e la scelta fra i due possibili intervalli
viene fatta dinamicamente dal kernel a seconda della memoria disponibile per
la gestione delle relative tabelle.
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
+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}.
+Data una connessione TCP, ma la cosa vale anche per altri protocolli del
+livello di trasporto come UDP, si suole chiamare \itindex{socket~pair}
+\textit{socket pair}\footnote{da non confondere con la coppia di socket della
+ omonima funzione \func{socketpair} di sez.~\ref{sec:ipc_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}
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}
+\begin{Terminal}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
-\end{verbatim}
+\end{Terminal}
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 è
+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 \texttt{0.0.0.0} usata da
-\cmd{netstat} è equivalente all'asterisco utilizzato per il numero di porta,
+\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}).
+definito in \headfiled{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
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ò
+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
+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
+l'indirizzo di \textit{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 \textit{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},
+assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà
+espressa dalla \textit{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
+Alla ricezione della richiesta dal client il server creerà un processo figlio
per gestire la connessione, se a questo punto eseguiamo nuovamente il
programma \cmd{netstat} otteniamo come risultato:
-\begin{verbatim}
+\begin{Terminal}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
-\end{verbatim}
+\end{Terminal}
-Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
-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
+Come si può notare il server è ancora in ascolto sulla porta 22, però adesso
+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 \cmd{ssh} per una seconda
-connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
+connessione quello che otterremo usando \cmd{netstat} sarà qualcosa del
genere:
-\begin{verbatim}
+\begin{Terminal}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN
tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED
tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED
-\end{verbatim}
-cioè il client effettuerà la connessione usando un'altra porta effimera: con
-questa sarà aperta la connessione, ed il server creerà un altro processo
+\end{Terminal}
+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 per gestirla.
-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\footnote{ad esempio con il comando \cmd{fuser}, o con \cmd{lsof}, o
- usando l'opzione \texttt{-p}.} 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.
+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
+\textit{socket pair}, compresa la porta dell'indirizzo remoto. E se andassimo
+a vedere quali sono i processi (ad esempio con il comando \cmd{fuser}, o con
+\cmd{lsof}, o usando l'opzione \texttt{-p}) 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 di base per la gestione dei socket}
\label{sec:TCP_functions}
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 sez.~\ref{sec:sock_socket}.
+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 sez.~\ref{sec:sock_creation}.
\subsection{La funzione \func{bind}}
\label{sec:TCP_func_bind}
La funzione \funcd{bind} assegna un indirizzo locale ad un
-socket.\footnote{nel nostro caso la utilizzeremo per socket TCP, ma la
- funzione è generica e deve essere usata per qualunque tipo di socket
- \const{SOCK\_STREAM} prima che questo possa accettare connessioni.} È 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)}
-
- 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:
+socket,\footnote{nel nostro caso la utilizzeremo per socket TCP, ma la
+ funzione è generica e deve essere usata per qualunque tipo di socket
+ \const{SOCK\_STREAM} prima che questo possa accettare connessioni.} ed è
+usata cioè per specificare la prima parte dalla \textit{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{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t
+ addrlen)}
+\fdesc{Assegna un indirizzo ad un socket.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{EBADF}] il file descriptor non è valido.
- \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato.
- \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket.
- \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
+ \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza
sufficienti privilegi.
- \item[\errcode{EADDRNOTAVAIL}] Il tipo di indirizzo specificato non è
+ \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
+ \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.
+ \end{errlist}
+ ed \errval{EFAULT} nel suo significato generico, inoltre per i socket di
+ tipo \const{AF\_UNIX}:
+ \begin{errlist}
+ \item[\errcode{EADDRNOTAVAIL}] il tipo di indirizzo specificato non è
disponibile.
- \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
\end{errlist}
- ed anche \errval{EFAULT} e per i socket di tipo \const{AF\_UNIX},
- \errval{ENOTDIR}, \errval{ENOENT}, \errval{ENOMEM}, \errval{ELOOP},
- \errval{ENOSR} e \errval{EROFS}.}
-\end{prototype}
+ ed \errval{ELOOP}, \errval{ENAMETOOLONG}, \errval{ENOENT}, \errval{ENOMEM},
+ \errval{ENOTDIR} e \errval{EROFS} nel loro significato generico.}
+\end{funcproto}
-Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
+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 sez.~\ref{sec:sock_sockaddr}.
+contiene, secondo quanto già trattato in sez.~\ref{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
+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 è
-per il server\footnote{un'eccezione a tutto ciò sono i server che usano RPC.
+\func{connect} o \func{listen}, ma se questo è normale per il client non lo è
+per il server\footnote{un'eccezione a tutto ciò sono i server che usano RPC.
In questo caso viene fatta assegnare dal kernel una porta effimera che poi
- viene registrata presso il \textit{portmapper}; quest'ultimo è un altro
+ 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 (l'elenco di queste porte, e dei relativi servizi, è in
-\file{/etc/services}).
+cui risponde (l'elenco di queste porte, e dei relativi servizi, è in
+\conffile{/etc/services}).
-Con \func{bind} si può assegnare un indirizzo IP specifico ad un socket,
-purché questo appartenga ad una interfaccia della macchina. Per un client TCP
-questo diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati
-sul socket, mentre per un server TCP questo restringerà l'accesso al socket
+Con \func{bind} si può assegnare un indirizzo IP specifico ad un socket,
+purché questo appartenga ad una interfaccia della macchina. Per un client TCP
+questo diventerà l'indirizzo sorgente usato per i tutti i pacchetti inviati
+sul 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 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.
+base dell'interfaccia usata per trasmettere i pacchetti, che dipenderà dalle
+regole di instradamento usate per raggiungere il server (è comunque possibile
+impostarlo in maniera specifica con i comandi di gestione avanzata del
+routing, vedi sez.~7.3.4 di \cite{AGL}). 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
-sez.~\ref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
-fig.~\ref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione
+sez.~\ref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio
+fig.~\ref{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
-\const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
+Si noti che si è usato \func{htonl} per assegnare il valore
+\const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è
inutile. Si tenga presente comunque che tutte le costanti \val{INADDR\_}
(riportate in tab.~\ref{tab:TCP_ipv4_addr}) sono definite secondo
-l'\textit{endianess}\itindex{endianess} della macchina, ed anche se
-esse possono essere invarianti rispetto all'ordinamento dei bit, è comunque
-buona norma usare sempre la funzione \func{htonl}.
+l'\textit{endianness} 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
\textbf{Costante} & \textbf{Significato} \\
\hline
\hline
- \const{INADDR\_ANY} & Indirizzo generico (\texttt{0.0.0.0})\\
- \const{INADDR\_BROADCAST}& Indirizzo di \itindex{broadcast}
- \textit{broadcast}.\\
- \const{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback}
- (\texttt{127.0.0.1}).\\
- \const{INADDR\_NONE} & Indirizzo errato.\\
+ \constd{INADDR\_ANY} & Indirizzo generico (\texttt{0.0.0.0})\\
+ \constd{INADDR\_BROADCAST}& Indirizzo di \textit{broadcast}.\\
+ \constd{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback}
+ (\texttt{127.0.0.1}).\\
+ \constd{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
+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
+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
-\macro{in6addr\_any} (dichiarata come \direct{extern}, ed inizializzata dal
-sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
+Per questo motivo nell'header \headfile{netinet/in.h} è definita una variabile
+\var{in6addr\_any} (dichiarata come \dirct{extern}, ed inizializzata dal
+sistema al valore \constd{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 \macro{in6addr\_loopback} per
+maniera analoga si può utilizzare la variabile \var{in6addr\_loopback} per
indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata
-staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}.
-
+staticamente a \constd{IN6ADRR\_LOOPBACK\_INIT}.
\subsection{La funzione \func{connect}}
\label{sec:TCP_func_connect}
-La funzione \funcd{connect} è usata da un client TCP per stabilire la
-connessione con un server TCP,\footnote{di nuovo la funzione è generica e
- supporta vari tipi di socket, la differenza è che per socket senza
+La funzione \funcd{connect} è usata da un client TCP per stabilire la
+connessione con un server TCP,\footnote{di nuovo la funzione è generica e
+ supporta vari tipi di socket, la differenza è che per socket senza
connessione come quelli di tipo \const{SOCK\_DGRAM} la sua chiamata si
- limiterà ad impostare l'indirizzo dal quale e verso il quale saranno inviati
+ limiterà ad impostare l'indirizzo dal quale e verso il quale saranno inviati
e ricevuti i pacchetti, mentre per socket di tipo \const{SOCK\_STREAM} o
- \const{SOCK\_SEQPACKET}, essa attiverà la procedura di avvio (nel caso del
- TCP il \itindex{three~way~handshake}\textit{three way handshake}) della
- connessione.} il prototipo della funzione è il seguente:
-\begin{prototype}{sys/socket.h}
- {int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t
+ \const{SOCK\_SEQPACKET}, essa attiverà la procedura di avvio (nel caso del
+ TCP il \textit{three way handshake}) della connessione.} il prototipo della
+funzione è il seguente:
+
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t
addrlen)}
-
- 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:
+\fdesc{Stabilisce una connessione fra due socket.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
- remoto.
- \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
- connessione.
- \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
- \item[\errcode{EINPROGRESS}] il socket è non bloccante (vedi
- sez.~\ref{sec:file_noblocking}) e la connessione non può essere conclusa
- immediatamente.
- \item[\errcode{EALREADY}] il socket è non bloccante (vedi
- sez.~\ref{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{EACCES}, \errcode{EPERM}] si è tentato di eseguire una
+ connessione ad un indirizzo \textit{broadcast} senza che il socket fosse
+ stato abilitato per il \textit{broadcast}.
\item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
corretta nel relativo campo.
- \item[\errcode{EACCES}, \errcode{EPERM}] si è tentato di eseguire una
- connessione ad un indirizzo \itindex{broadcast} \textit{broadcast} senza
- che il socket fosse stato abilitato per il \itindex{broadcast}
- \textit{broadcast}.
+ \item[\errcode{EAGAIN}] non ci sono più porte locali libere.
+ \item[\errcode{EALREADY}] il socket è non bloccante (vedi
+ sez.~\ref{sec:file_noblocking}) e un tentativo precedente di connessione
+ non si è ancora concluso.
+ \item[\errcode{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo
+ remoto.
+ \item[\errcode{EINPROGRESS}] il socket è non bloccante (vedi
+ sez.~\ref{sec:file_noblocking}) e la connessione non può essere conclusa
+ immediatamente.
+ \item[\errcode{ENETUNREACH}] la rete non è raggiungibile.
+ \item[\errcode{ETIMEDOUT}] si è avuto timeout durante il tentativo di
+ connessione.
\end{errlist}
- altri errori possibili sono: \errval{EFAULT}, \errval{EBADF},
- \errval{ENOTSOCK}, \errval{EISCONN} e \errval{EADDRINUSE}.}
-\end{prototype}
+ ed inoltre \errval{EADDRINUSE}, \errval{EBADF}, \errval{EFAULT},
+ \errval{EINTR}, \errval{EISCONN} e \errval{ENOTSOCK} e nel loro significato
+ generico.}
+\end{funcproto}
-Il primo argomento è un file descriptor ottenuto da una precedente chiamata a
+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 sez.~\ref{sec:sock_sockaddr}.
+socket, già descritta in sez.~\ref{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 sez.~\ref{sec:TCP_daytime_client}, usando le funzioni illustrate
-in sez.~\ref{sec:sock_addr_func}.
-
-Nel caso di socket TCP la funzione \func{connect} avvia il
-\itindex{three~way~handshake}\textit{three way handshake}, e ritorna
-solo quando la connessione è stabilita o si è verificato un errore. Le
-possibili cause di errore sono molteplici (ed i relativi codici riportati
-sopra), quelle che però dipendono dalla situazione della rete e non da errori
-o problemi nella chiamata della funzione sono le seguenti:
+numero di porta del server a cui ci si vuole connettere usando le funzioni
+illustrate in sez.~\ref{sec:sock_addr_func} come mostrato nell'esempio che
+vedremo in sez.~\ref{sec:TCP_daytime_client}.
+
+Nel caso di socket TCP la funzione \func{connect} avvia il \textit{three way
+ handshake}, e ritorna solo quando la connessione è stabilita o si è
+verificato un errore. Le possibili cause di errore sono molteplici (ed i
+relativi codici riportati sopra), quelle che però dipendono dalla situazione
+della rete e non da errori o problemi nella chiamata della funzione sono le
+seguenti:
\begin{enumerate}
-\item Il client non riceve risposta al SYN: l'errore restituito è
- \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 predefinito
- per la ripetizione dell'invio è di 5 volte, che comporta un timeout dopo
- circa 180 secondi.
-
-\item Il client riceve come risposta al SYN un RST significa che non c'è
+\item Il client non riceve risposta al SYN: l'errore restituito è
+ \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. Questo
+ può essere fatto a livello globale con una opportuna \func{sysctl} (o più
+ semplicemente scrivendo il valore voluto in
+ \sysctlfile{net/ipv4/tcp\_syn\_retries}, vedi
+ sez.~\ref{sec:sock_ipv4_sysctl}) e a livello di singolo socket con l'opzione
+ \const{TCP\_SYNCNT} (vedi sez.~\ref{sec:sock_tcp_udp_options}). Il valore
+ predefinito per la ripetizione dell'invio è di 5 volte, che comporta un
+ timeout dopo circa 180 secondi.
+
+\item Il client riceve come risposta al SYN un RST significa che non c'è
nessun programma in ascolto per la connessione sulla porta specificata (il
- che vuol dire probabilmente che o si è sbagliato il numero della porta o che
- non è stato avviato il server), questo è un errore fatale e la funzione
+ 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
\errcode{ECONNREFUSED}.
- Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
+ Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
quando arriva un SYN per una porta che non ha nessun server in ascolto,
quando il TCP abortisce una connessione in corso, quando TCP riceve un
segmento per una connessione che non esiste.
\item Il SYN del client provoca l'emissione di un messaggio ICMP di
- destinazione non raggiungibile. In questo caso dato che il messaggio può
+ destinazione non raggiungibile. In questo caso dato che il messaggio può
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
\end{enumerate}
Se si fa riferimento al diagramma degli stati del TCP riportato in
-fig.~\ref{fig:TCP_state_diag} la funzione \func{connect} porta un socket
-dallo stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket
-appena creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento del
-ACK, nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il
-socket non è più utilizzabile e deve essere chiuso.
-
-Si noti infine che con la funzione \func{connect} si è specificato solo
-indirizzo e porta del server, quindi solo una metà della socket pair; essendo
-questa funzione usata nei client l'altra metà contenente indirizzo e porta
-locale viene lasciata all'assegnazione automatica del kernel, e non è
+fig.~\ref{fig:TCP_state_diag} la funzione \func{connect} porta un socket dallo
+stato \texttt{CLOSED} (lo stato iniziale in cui si trova un socket appena
+creato) prima allo stato \texttt{SYN\_SENT} e poi, al ricevimento dell'ACK,
+nello stato \texttt{ESTABLISHED}. Se invece la connessione fallisce il socket
+non è più utilizzabile e deve essere chiuso.
+
+Si noti infine che con la funzione \func{connect} si è specificato solo
+indirizzo e porta del server, quindi solo una metà della \textit{socket pair};
+essendo questa funzione usata nei client l'altra metà contenente indirizzo e
+porta locale viene lasciata all'assegnazione automatica del kernel, e non è
necessario effettuare una \func{bind}.
\subsection{La funzione \func{listen}}
\label{sec:TCP_func_listen}
-La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
+La funzione \funcd{listen} serve ad usare un socket in modalità passiva, cioè,
come dice il nome, per metterlo in ascolto di eventuali
-connessioni;\footnote{questa funzione può essere usata con socket che
- supportino le connessioni, cioè di tipo \const{SOCK\_STREAM} o
- \const{SOCK\_SEQPACKET}.} in sostanza l'effetto della funzione è di portare
+connessioni;\footnote{questa funzione può essere usata con socket che
+ supportino le connessioni, cioè di tipo \const{SOCK\_STREAM} o
+ \const{SOCK\_SEQPACKET}.} in sostanza l'effetto della funzione è di portare
il socket dallo stato \texttt{CLOSED} a quello \texttt{LISTEN}. In genere si
chiama la funzione in un server dopo le chiamate a \func{socket} e \func{bind}
e prima della chiamata ad \func{accept}. Il prototipo della funzione, come
-definito dalla pagina di manuale, è:
-\begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
- 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:
+definito dalla pagina di manuale, è:
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int listen(int sockfd, int backlog)}
+\fdesc{Pone un socket in attesa di una connessione.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo.
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
valido.
- \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
- \item[\errcode{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{prototype}
+ \end{errlist}
+}
+\end{funcproto}
-La funzione pone il socket specificato da \param{sockfd} in modalità passiva e
+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}.
-
-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à
+\param{backlog}. La funzione si può applicare solo a socket di tipo
+\const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}. 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 La coda delle connessioni incomplete (\textit{incomplete connection
- queue} che contiene un riferimento per ciascun socket per il quale è
- arrivato un SYN ma il \itindex{three~way~handshake}\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 \textit{three
- way handshake} è stato completato ma ancora \func{accept} non è ritornata.
+ queue}) che contiene una voce 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 una voce per ciascun socket per il quale il \textit{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 fig.~\ref{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
-\itindex{three~way~handshake}\textit{three way handshake} la voce viene
+Lo schema di funzionamento è descritto in fig.~\ref{fig:TCP_listen_backlog}:
+quando arriva un segmento SYN da un client il kernel crea una voce nella coda
+delle connessioni incomplete e risponde con il segmento SYN$+$ACK. La voce
+resterà nella coda delle connessioni incomplete fino al ricevimento del
+segmento ACK dal client o fino ad un timeout.
+
+Nel caso di completamento del \textit{three way handshake} la voce viene
spostata nella coda delle connessioni complete. Quando il processo chiama la
-funzione \func{accept} (vedi sez.~\ref{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.
+funzione \func{accept} (vedi sez.~\ref{sec:TCP_func_accept}) gli viene passata
+la prima voce nella coda delle connessioni complete, oppure, se la coda è
+vuota, il processo viene posto in attesa in stato di \textit{sleep} e
+risvegliato all'arrivo della prima connessione completa.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=11cm]{img/tcp_listen_backlog}
+\begin{figure}[!htb]
+ \centering \includegraphics[width=12cm]{img/tcp_listen_backlog}
\caption{Schema di funzionamento delle code delle connessioni complete ed
incomplete.}
\label{fig:TCP_listen_backlog}
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
+kernel, compreso anche il vecchio Linux 2.0, che mostrano le differenze fra
+diverse realizzazioni.
+
+In Linux il significato di questo valore è cambiato a partire dal kernel 2.2
+per prevenire il \textit{denial of service} chiamato \itindex{SYN~flood}
+\textit{SYN flood}. Questo attacco si basa sull'emissione da parte
+dell'attaccante di un grande numero di segmenti SYN indirizzati verso una
+porta, forgiati con indirizzo IP fasullo (con la tecnica che viene detta
+\textit{ip spoofing}); in questo modo i segmenti SYN$+$ACK di risposta vanno
perduti e la coda delle connessioni incomplete viene saturata, impedendo di
fatto ulteriori connessioni.
-Per ovviare a questo il significato del \param{backlog} è stato cambiato a
-indicare la lunghezza della coda delle connessioni complete. La lunghezza
-della coda delle connessioni incomplete può essere ancora controllata usando
-la funzione \func{sysctl} con il parametro \const{NET\_TCP\_MAX\_SYN\_BACKLOG}
-o scrivendola direttamente in
-\file{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
-protezione dei syncookies però (con l'opzione da compilare nel kernel e da
-attivare usando \file{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore viene
-ignorato e non esiste più un valore massimo. In ogni caso in Linux il valore
-di \param{backlog} viene troncato ad un massimo di \const{SOMAXCONN} se è
-superiore a detta costante (che di default vale 128).
-
-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
-sez.~\ref{sec:proc_environ}).
+Per ovviare a questo problema il significato del \param{backlog} è stato
+cambiato e adesso indica la lunghezza della coda delle connessioni
+complete. La lunghezza della coda delle connessioni incomplete può essere
+ancora controllata ma occorre usare esplicitamente la funzione \func{sysctl}
+con il parametro \constd{NET\_TCP\_MAX\_SYN\_BACKLOG} o scrivere il valore
+direttamente sul file \sysctlfile{net/ipv4/tcp\_max\_syn\_backlog}.
+
+Quando si attiva la protezione dei \textit{syncookies} però (con l'opzione da
+compilare nel kernel e da attivare usando \func{sysctl} o scrivendo nel file
+\sysctlfile{net/ipv4/tcp\_syncookies}, vedi sez.~\ref{sec:sock_ipv4_sysctl})
+questo valore viene ignorato e non esiste più un valore massimo. In ogni caso
+in Linux il valore di \param{backlog} viene sempre troncato ad un massimo di
+\const{SOMAXCONN} se è superiore a detta costante (che di default vale 128);
+per i kernel precedenti il 2.4.25 questo valore era fisso e non modificabile,
+nelle versioni successive può essere controllato con un parametro di
+\func{sysctl}, o scrivendo nel file \sysctlfile{net/core/somaxconn}
+(vedi sez.~\ref{sec:sock_ioctl_IP}).
+
+La scelta storica per il valore assegnato a questo argomento 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 sez.~\ref{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
-\textit{three way handshake}\itindex{three~way~handshake}.
-
-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
-condizione di errore, costringendo a inserire nell'applicazione la gestione
-dei tentativi di riconnessione, che invece può essere effettuata in maniera
-trasparente dal protocollo TCP.
+da casistiche reali trovate su dei server web, 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 \textit{three way handshake}.
+
+Infine va messo in evidenza che, nel caso di socket TCP, quando un segmento
+SYN arriva con tutte le code piene, il pacchetto verrà semplicemente
+ignorato. Questo avviene perché la condizione in cui le code sono piene è
+ovviamente transitoria, per cui se il client ritrasmette in seguito un
+segmento SYN, come previsto dal protocollo, è probabile che essendo passato un
+po' di tempo esso possa trovare nella coda lo spazio per una nuova
+connessione.
+
+Se al contrario si rispondesse immediatamente con un segmento RST, per
+indicare che è impossibile effettuare la connessione, la chiamata a
+\func{connect} eseguita dal client fallirebbe ritornando una condizione di
+errore. In questo modo si sarebbe costretti ad inserire nell'applicazione la
+gestione dei tentativi di riconnessione, che invece grazie a questa modalità
+di funzionamento viene effettuata in maniera trasparente dal protocollo
+TCP.
\subsection{La funzione \func{accept}}
\label{sec:TCP_func_accept}
-La funzione \funcd{accept} è chiamata da un server per gestire la connessione
-una volta che sia stato completato il \itindex{three~way~handshake}
-\textit{three way handshake},\footnote{la funzione è comunque generica ed è
+La funzione \funcd{accept} è chiamata da un server per gestire la connessione,
+nel caso di TCP una volta che sia stato completato il \textit{three way
+ handshake};\footnote{come le precedenti, la funzione è generica ed è
utilizzabile su socket di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET}
- e \const{SOCK\_RDM}.} la funzione restituisce un nuovo socket descriptor su
-cui si potrà operare per effettuare la comunicazione. Se non ci sono
+ e \const{SOCK\_RDM}, ma qui la tratteremo solo per gli aspetti riguardanti
+ le connessioni con TCP.} 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)}
-
- 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:
+funzione è il seguente:
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
+\fdesc{Accetta una connessione sul socket specificato.}
+}
+
+{La funzione ritorna un numero di socket descriptor positivo in caso di
+ successo e $-1$ per un errore, nel qual caso \var{errno} assumerà uno dei
+ valori:
\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{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
- operazione.
- \item[\errcode{EAGAIN} o \errcode{EWOULDBLOCK}] il socket è stato impostato
+ \item[\errcode{EAGAIN} o \errcode{EWOULDBLOCK}] il socket è stato impostato
come non bloccante (vedi sez.~\ref{sec:file_noblocking}), e non ci sono
- connessioni in attesa di essere accettate.
- \item[\errcode{EPERM}] Le regole del firewall non consentono la connessione.
+ connessioni in attesa di essere accettate. In generale possono essere
+ restituiti entrambi i valori, per cui se si ha a cuore la portabilità
+ occorre controllare entrambi.
+ \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ valido.
+ \item[\errcode{ECONNABORTED}] la connessione è stata abortita.
+ \item[\errcode{EINTR}] la funzione è stata interrotta da un segnale.
+ \item[\errcode{EINVAL}] il socket non è in ascolto o \param{addrlen} non ha
+ un valore valido.
\item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che
- l'allocazione della memoria è limitata dai limiti sui buffer dei socket,
+ 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.
+ \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{EPERM}] le regole del firewall non consentono la connessione.
\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}
+ ed inoltre nel loro significato generico: \errval{EFAULT}, \errval{EMFILE},
+ \errval{ENFILE}; infine a seconda del protocollo e del kernel possono essere
+ restituiti errori di rete relativi al nuovo socket come: \errval{ENOSR},
+ \errval{ESOCKTNOSUPPORT}, \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT},
+ \errval{ERESTARTSYS}.}
+\end{funcproto}
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.
-
-I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è
-passato per indirizzo per avere indietro il valore) sono usati per ottenere
-l'indirizzo del client da cui proviene la connessione. Prima della chiamata
-\param{addrlen} deve essere inizializzato alle dimensioni della struttura il
-cui indirizzo è passato come argomento in \param{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.
+posto nello stato \texttt{ESTABLISHED}.
+
+I due argomenti \param{addr} e \param{addrlen} (si noti che quest'ultimo è un
+\textit{valure-result argument} passato con un puntatore per riavere indietro
+il valore) sono usati rispettivamente per ottenere l'indirizzo del client da
+cui proviene la connessione e la lunghezza dello stesso; la dimensione dipende
+da quale famiglia di indirizzi si sta utilizzando. Prima della
+chiamata \param{addrlen} deve essere inizializzato alle dimensioni della
+struttura degli indirizzi cui punta \param{addr} (un numero positivo); 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
sez.~\ref{sec:TCP_func_listen}) che il client ha effettuato verso il socket
-\param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato
+\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 sez.~\ref{sec:file_noblocking}), nel qual caso
- ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di
+ ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di
operazione in sez.~\ref{sec:TCP_sock_multiplexing}.} 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
+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 sez.~\ref{sec:TCP_echo_critical}).
-Un'altra differenza con BSD è che la funzione non fa ereditare al nuovo socket
+connessione viene eseguito con la funzione \func{close}.
+
+Si tenga presente che con Linux, seguendo POSIX.1, è sufficiente includere
+\texttt{sys/socket.h}, ma alcune implementazioni di altri sistemi possono
+richiedere l'inclusione di \texttt{sys/types.h}, per cui dovendo curare la
+portabilità può essere il caso di includere anche questo file. Inoltre Linux
+presenta un comportamento diverso nella gestione degli errori rispetto ad
+altre realizzazioni 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 sez.~\ref{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
- sez.~\ref{sec:file_fcntl}.} che devono essere rispecificati ogni volta. Tutto
-questo deve essere tenuto in conto se si devono scrivere programmi portabili.
+ sez.~\ref{sec:file_fcntl_ioctl}.} che devono essere rispecificati ogni
+volta. Tutto questo deve essere tenuto in conto se si devono scrivere
+programmi portabili. Per poter effettuare questa impostazione in maniera
+atomica, senza dover ricorrere ad ulteriori chiamate a \func{fcntl} su Linux è
+disponibile anche la funzione \funcd{accept4}, il cui prototipo è:\footnote{la
+ funzione è utilizzabile solo se si è definito la macro \macro{\_GNU\_SOURCE}
+ ed ovviamente non è portabile.}
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int accept4(int sockfd, struct sockaddr *addr, socklen\_t *addrlen, int
+ flags)}
+\fdesc{Accetta una connessione sul socket specificato.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà gli stessi valori di \func{accept}.}
+\end{funcproto}
+
+La funzione aggiunge un quarto argomento \param{flags} usato come maschera
+binaria, e se questo è nullo il suo comportamento è identico a quello di
+\func{accept}. Con \param{flags} si possono impostare contestualmente
+all'esecuzione sul file descriptor restituito i due flag di
+\const{O\_NONBLOCK} e \const{O\_CLOEXEC}, fornendo un valore che sia un OR
+aritmetico delle costanti in tab.\ref{tab:accept4_flags_arg}.
-Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
-funzionamento di un server: in generale infatti c'è sempre un solo socket in
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|}
+ \hline
+ \textbf{Costante} & \textbf{Significato} \\
+ \hline
+ \hline
+ \constd{SOCK\_NONBLOCK} & imposta sul file descriptor restituito il flag
+ di \const{O\_NONBLOCK}\\
+ \constd{SOCK\_NOXEC} & imposta sul file descriptor restituito il flag
+ di \const{O\_CLOEXEC}\\
+ \hline
+ \end{tabular}
+ \caption{Costanti per i possibili valori dell'argomento \param{flags} di
+ \func{accept4}.}
+ \label{tab:accept4_flags_arg}
+\end{table}
+
+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, 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
+della connessione. Si può riconoscere questo schema anche nell'esempio
elementare di fig.~\ref{fig:TCP_daytime_iter_server_code}, dove per ogni
connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei
dati.
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:
+più elementari sono le seguenti, usate per ottenere i dati relativi alla
+\textit{socket pair} associata ad un certo socket. La prima è
+\funcd{getsockname} e serve ad ottenere l'indirizzo locale associato ad un
+socket; il suo prototipo è:
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int getsockname(int sockfd, struct sockaddr *name, socklen\_t *namelen)}
+\fdesc{Legge l'indirizzo locale di un socket.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ \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
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
eseguire l'operazione.
- \item[\errcode{EFAULT}] l'indirizzo \param{name} non è valido.
- \end{errlist}}
-\end{prototype}
+ \end{errlist}
+ ed \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
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.
+nella struttura indicata dal puntatore \param{name} la cui lunghezza è
+specificata tramite l'argomento \param{namlen}. Quest'ultimo è un
+\textit{value result argument} e pertanto 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
+socket; ad esempio può essere usata da un client (che usualmente non chiama
+\func{bind}) per ottenere l'indirizzo IP e la 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
+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:
+quella connessione. Invece tutte le volte che si vuole avere l'indirizzo
+remoto di un socket si usa la funzione \funcd{getpeername}, il cui prototipo
+è:
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int getpeername(int sockfd, struct sockaddr * name, socklen\_t *
+ namelen)}
+\fdesc{Legge l'indirizzo remoto di un socket.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
- \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor
+ \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}
+ \item[\errcode{ENOTCONN}] il socket non è connesso.
+ \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket.
+ \end{errlist}
+ ed \errval{EFAULT} nel suo significato generico.}
+\end{funcproto}
-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
+
+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
fig.~\ref{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
+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 sez.~\ref{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
+connessione un altro programma, usando \func{exec}. Questa ad esempio è la
+modalità con cui opera il \textsl{super-server} \cmd{xinetd}, 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 argomento, 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
+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 (ad esempio il solito
+\cmd{xinetd} 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 argomento, 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 realizzazioni dei
socket BSD fanno questa assunzione.
\subsection{La funzione \func{close}}
\label{sec:TCP_func_close}
-La funzione standard Unix \func{close} (vedi sez.~\ref{sec:file_close}) che si
-usa sui file può essere usata con lo stesso effetto anche sui file descriptor
-associati ad un socket.
+La funzione standard Unix \func{close} (vedi sez.~\ref{sec:file_open_close})
+che si usa sui file può essere usata con lo stesso effetto anche sui file
+descriptor associati ad un socket.
-L'azione di questa funzione quando applicata a socket è di marcarlo come
+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
+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 sez.~\ref{sec:sock_generic_options} come sia possibile
-cambiare questo comportamento, e cosa può essere fatto perché il processo
-possa assicurarsi che l'altro capo abbia ricevuto tutti i dati.
+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 sez.~\ref{sec:sock_generic_options} come sia possibile cambiare
+questo comportamento, e cosa può essere fatto perché il processo possa
+assicurarsi che l'altro capo abbia ricevuto tutti i dati.
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
+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 si applica, come
-visto in sez.~\ref{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.
+visto in sez.~\ref{sec:file_shared_access}, 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 sez.~\ref{sec:TCP_conn_term}, si può invece usare la funzione
+descritta in sez.~\ref{sec:TCP_conn_term}, si può invece usare la funzione
\func{shutdown} su cui torneremo in seguito (vedi
sez.~\ref{sec:TCP_shutdown}).
-
\section{Un esempio elementare: il servizio \textit{daytime}}
\label{sec:TCP_daytime_application}
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
+realizza il servizio \textit{daytime} su TCP, secondo quanto specificato
dall'\href{http://www.ietf.org/rfc/rfc867.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
-sez.~\ref{sec:file_read} e sez.~\ref{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.
+dettagli una peculiarità delle funzioni di I/O, già accennata in
+sez.~\ref{sec:file_read} e sez.~\ref{sec:file_write}, che nel caso dei socket
+è particolarmente rilevante. Passeremo poi ad illustrare gli esempi della
+realizzazione, sia dal lato client, che dal lato server, che si è effettuata
+sia in forma iterativa che concorrente.
\subsection{Il comportamento delle funzioni di I/O}
\label{sec:sock_io_behav}
-Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
+Una cosa che si tende a dimenticare quando si ha a che fare con i socket è che
le funzioni di input/output non sempre hanno lo stesso comportamento che
avrebbero con i normali file di dati (in particolare questo accade per i
socket di tipo stream).
-Infatti con i socket è comune che funzioni come \func{read} o \func{write}
+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 sez.~\ref{sec:file_read} questo è un
+quello richiesto. Come già accennato in sez.~\ref{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.
+generale non è così, e con i socket questo è particolarmente evidente.
-\begin{figure}[htb]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/FullRead.c}
\end{minipage}
\normalsize
\end{figure}
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
+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
+sono disponibili: è lo stesso comportamento che si può avere scrivendo più di
+\const{PIPE\_BUF} byte in una \textit{pipe} (si riveda quanto detto in
sez.~\ref{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
-fig.~\ref{fig:sock_FullRead_code} e fig.~\ref{fig:sock_FullWrite_code} ed è
+specificato; il sorgente è riportato rispettivamente in
+fig.~\ref{fig:sock_FullRead_code} e fig.~\ref{fig:sock_FullWrite_code} ed è
disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e
\file{FullWrite.c}.
-\begin{figure}[htb]
+\begin{figure}[!htbp]
\centering
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/FullWrite.c}
\end{minipage}
\normalsize
\label{fig:sock_FullWrite_code}
\end{figure}
-Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo
+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.
+controllato se questo è \errcode{EINTR} (cioè un'interruzione della
+\textit{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 è
+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
+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, \func{FullRead} restituisce il numero di
-byte non letti in caso di end-of-file prematuro.
+byte non letti in caso di \textit{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
-sez.~\ref{sec:TCP_functions} è relativo alla creazione di un client elementare
+sez.~\ref{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/rfc867.txt}{RFC~867}, che restituisce
-l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
+l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato
alla porta 13.
-In fig.~\ref{fig:TCP_daytime_client_code} è riportata la sezione principale
+In fig.~\ref{fig:TCP_daytime_client_code} è riportata la sezione principale
del codice del nostro client. Il sorgente completo del programma
(\texttt{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
+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]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/TCP_daytime.c}
\end{minipage}
\normalsize
\end{figure}
Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari;
-dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
+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
sez.~\ref{sec:proc_opt_handling}).
-Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo
+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}) è
+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ò
+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
+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.
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 è
+ 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è
+funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè
qualcosa del tipo:
-\begin{verbatim}
+\begin{Verbatim}
Wed Apr 4 00:53:00 2001\r\n
-\end{verbatim}
+\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}.
+ 36}) sullo \textit{standard output} con l'uso di \func{fputs}.
-Come si è già spiegato in sez.~\ref{sec:sock_io_behav} la risposta dal socket
-potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel
+Come si è già spiegato in sez.~\ref{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
+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
+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
+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} \cmd{inetd}, pertanto basta
+ fornito direttamente dal \textsl{superdemone} \cmd{xinetd}, 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
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./daytime 127.0.0.1}
Mon Apr 21 20:46:11 2003
-\end{verbatim}%$
+\end{Console}
+%$
e come si vede tutto funziona regolarmente.
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
+risposta alla volta. Il codice del programma è nuovamente mostrato in
fig.~\ref{fig:TCP_daytime_iter_server_code}, il sorgente completo
-(\texttt{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli
+(\texttt{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli
esempi.
\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/TCP_iter_daytimed.c}
\end{minipage}
\normalsize
\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
+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,
+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
+porta standard del servizio \textit{daytime}, ma come indirizzo IP si usa
+(\texttt{\small 29}) il valore predefinito \const{INET\_ANY}, che corrisponde
all'indirizzo generico.
Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind}
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 argomento, 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.
+Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``\textsl{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
+argomento, 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ò
+(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
+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
+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
+\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
+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
+È 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
-sez.~\ref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma
+modifiche (come una chiamata a \func{daemon} prima dell'inizio del ciclo
+principale) per tener conto di quanto illustrato in
+sez.~\ref{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.
+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
-sez.~\ref{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
+sez.~\ref{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 sez.~\ref{sec:proc_gen} una delle modalità più comuni
-di funzionamento da parte dei server è quella di usare la funzione \func{fork}
+Come spiegato in sez.~\ref{sec:proc_fork} 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
+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 fig.~\ref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del
+In fig.~\ref{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
+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 \texttt{TCP\_cunc\_daytimed.c}, è allegato insieme ai
+server, nel file \texttt{TCP\_cunc\_daytimed.c}, è allegato insieme ai
sorgenti degli altri esempi.
-\begin{figure}[!htb]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/TCP_cunc_daytimed.c}
\end{minipage}
\normalsize
\label{fig:TCP_daytime_cunc_server_code}
\end{figure}
-Stavolta (\texttt{\small 21--26}) la funzione \func{accept} è chiamata
+Stavolta (\texttt{\small 21--26}) 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 40--44}), se il logging è abilitato, stamperemo sullo standard
-output.
+(\texttt{\small 40--44}), se il logging è abilitato, stamperemo sullo
+\textit{standard output}.
Quando \func{accept} ritorna il server chiama la funzione \func{fork}
-(\texttt{\small 27--31}) per creare il processo figlio che effettuerà
+(\texttt{\small 27--31}) per creare il processo figlio che effettuerà
(\texttt{\small 32--46}) tutte le operazioni relative a quella connessione,
-mentre il padre proseguirà l'esecuzione del ciclo principale in attesa di
+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
continua ad operare solo sul socket in ascolto chiudendo (\texttt{\small 48})
\var{conn\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in
sez.~\ref{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.
+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{conn\_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 45}) la funzione \func{close}.
+e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato
+le sue operazioni, chiamerà (\texttt{\small 45}) la funzione \func{close}.
-In realtà per il figlio non sarebbe necessaria nessuna chiamata a
+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
+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
+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
+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.
(\texttt{\small 35}) sulla stringa contenuta in \var{buffer} con l'uso di
\func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small
36--39}) 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.
+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 40--43}) 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{ntohs}.
-
-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,
+provvede anche (\texttt{\small 40--43}) a stampare sullo \textit{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{ntohs}.
+
+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ù
+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}}
+\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
+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
+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,
+Ci limiteremo a fornire una realizzazione 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
+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
+reale di un'applicazione di rete, fino ad arrivare ad una realizzazione
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
+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
+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
+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
+Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti
+direttamente dal superserver \cmd{inetd}, ed è definito
dall'\href{http://www.ietf.org/rfc/rfc862.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
+qil 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.
+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.
+Nel nostro caso l'esempio sarà costituito da un client che legge una linea di
+caratteri dallo \textit{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 \textit{standard output}.
\subsection{Il client \textit{echo}: prima versione}
\label{sec:TCP_echo_client}
Il codice della prima versione del client per il servizio \textit{echo},
-disponibile nel file \texttt{TCP\_echo\_first.c}, è riportato in
+disponibile nel file \texttt{TCP\_echo\_first.c}, è riportato in
fig.~\ref{fig:TCP_echo_client_1}. Esso ricalca la struttura del precedente
client per il servizio \textit{daytime} (vedi
sez.~\ref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27})
-è sostanzialmente identica, a parte l'uso di una porta diversa.
+è sostanzialmente identica, a parte l'uso di una porta diversa.
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6 cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/TCP_echo_first.c}
\end{minipage}
\normalsize
\label{fig:TCP_echo_client_1}
\end{figure}
-Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a
+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
+(\texttt{\small 10--13}) con la 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
+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
sez.~\ref{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
+la funzione \code{ClientEcho}, il cui codice si è riportato a parte in
fig.~\ref{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.
+comunicazione, leggendo una riga alla volta dallo \textit{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
sez.~\ref{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 \func{read} li
+\func{read}\footnote{si è fatta l'assunzione implicita che i dati siano
+ contenuti tutti in un solo segmento, così che la chiamata a \func{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
+ 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}.
-\begin{figure}[!htb]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ClientEcho_first.c}
\end{minipage}
\normalsize
\label{fig:TCP_client_echo_sub}
\end{figure}
-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 sez.~\ref{sec:file_line_io}) e la conseguente uscita dal
-ciclo; al che la subroutine ritorna ed il nostro programma client termina.
+Quando si concluderà l'invio di dati mandando un \textit{end-of-file} sullo
+\textit{standard input} si avrà il ritorno di \func{fgets} con un puntatore
+nullo (si riveda quanto spiegato in sez.~\ref{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
+Si può effettuare una verifica del funzionamento del client abilitando il
+servizio \textit{echo} nella configurazione di \cmd{xinetd} sulla propria
macchina ed usandolo direttamente verso di esso in locale, vedremo in
-dettaglio più avanti (in sez.~\ref{sec:TCP_echo_startup}) il funzionamento del
-programma, usato però con la nostra versione del server \textit{echo}, che
+dettaglio più avanti (in sez.~\ref{sec:TCP_echo_startup}) il funzionamento del
+programma, usato però con la nostra versione del server \textit{echo}, che
illustriamo immediatamente.
\label{sec:TCPsimp_server_main}
La prima versione del server, contenuta nel file \texttt{TCP\_echod\_first.c},
-è riportata in fig.~\ref{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
+è riportata in fig.~\ref{fig:TCP_echo_server_first_code} e
+fig.~\ref{fig:TCP_echo_server_first_main}. 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
sez.~\ref{sec:TCP_daytime_cunc_server}, e da una funzione ausiliaria
\code{ServEcho} che si cura della gestione del servizio.
-\begin{figure}[!htbp]
+\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
- \includecodesample{listati/TCP_echod_first.c}
+ \begin{minipage}[c]{\codesamplewidth}
+ \includecodesample{listati/TCP_echod_first_init.c}
\end{minipage}
\normalsize
- \caption{Codice del corpo principale della prima versione del server
+ \caption{Codice di inizializzatione della prima versione del server
per il servizio \textit{echo}.}
\label{fig:TCP_echo_server_first_code}
\end{figure}
-In questo caso però, rispetto a quanto visto nell'esempio di
-fig.~\ref{fig:TCP_daytime_cunc_server_code} si è preferito scrivere il server
+In questo caso però, rispetto a quanto visto nell'esempio di
+fig.~\ref{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.
+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
+La sezione iniziale del programma (\texttt{\small 8--21}) è la stessa del
server di sez.~\ref{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à
+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
+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,
+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
+ 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 sez.~\ref{sec:proc_perms}) che usando queste due funzioni il
- rilascio dei privilegi è irreversibile.} Infine (\texttt{\small 30--36}),
+ 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 fig.~\ref{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--59}).
-All'interno di questo si ricevono (\texttt{\small 43--47}) le connessioni,
-creando (\texttt{\small 48--51}) un processo figlio per ciascuna di esse.
-Quest'ultimo (\texttt{\small 52--56}), chiuso (\texttt{\small 53}) il
-\textit{listening socket}, esegue (\texttt{\small 54}) la funzione di gestione
+
+\begin{figure}[!htb]
+ \footnotesize \centering
+ \begin{minipage}[c]{\codesamplewidth}
+ \includecodesample{listati/TCP_echod_first_main.c}
+ \end{minipage}
+ \normalsize
+ \caption{Codice di inizializzatione della prima versione del server
+ per il servizio \textit{echo}.}
+ \label{fig:TCP_echo_server_first_main}
+\end{figure}
+
+A questo punto il programma prosegue nel ciclo principale, illustrato in
+fig.~\ref{fig:TCP_echo_server_first_main}, usando lo schema già visto in
+precedenza per server per il servizio \textit{daytime}, con l'unica differenza
+della chiamata alla funzione \code{PrintErr}, riportata in
+fig.~\ref{fig:TCP_PrintErr}, al posto di \func{perror} per la stampa degli
+errori.
+
+Si inizia con il porre (\texttt{\small 3--6}) in ascolto il socket, e poi si
+esegue indefinitamente il ciclo principale (\texttt{\small 7--26}).
+All'interno di questo si ricevono (\texttt{\small 9--12}) le connessioni,
+creando (\texttt{\small 13--16}) un processo figlio per ciascuna di esse.
+Quest'ultimo (\texttt{\small 17--21}), chiuso (\texttt{\small 18}) il
+\textit{listening socket}, esegue (\texttt{\small 19}) la funzione di gestione
del servizio \code{ServEcho}, ed al ritorno di questa esce (\texttt{\small
- 55}).
+ 20}).
-Il padre invece si limita (\texttt{\small 57}) a chiudere il \textit{connected
+Il padre invece si limita (\texttt{\small 22}) 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 è
+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
+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
-sez.~\ref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando
-come \textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato
+sez.~\ref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando
+come \textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato
in fig.~\ref{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 sez.~\ref{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.
-
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\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}.}
+ \caption{Codice della funzione \code{PrintErr} per la generalizzazione della
+ stampa degli errori sullo \textit{standard input} o attraverso il
+ \texttt{syslog}.}
\label{fig:TCP_PrintErr}
\end{figure}
+
+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 sez.~\ref{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
+\textit{standard error}.
+
La gestione del servizio \textit{echo} viene effettuata interamente nella
-funzione \code{ServEcho}, il cui codice è mostrato in
+funzione \code{ServEcho}, il cui codice è mostrato in
fig.~\ref{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 fig.~\ref{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
+in arrivo.
+
+La riscrittura (\texttt{\small 7}) viene invece gestita dalla funzione
+\func{FullWrite} (descritta in fig.~\ref{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}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ServEcho_first.c}
\end{minipage}
\normalsize
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.
+la connessione il ricevimento del segmento 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}
+\subsection{L'avvio e il funzionamento ordinario}
\label{sec:TCP_echo_startup}
-Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà
+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
+modalità di funzionamento ordinarie, 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 (usando l'utente di
+amministrazione, per poter usare la porta 7 che è riservata). All'avvio 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{Console}
+[piccardi@roke piccardi]$ \textbf{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} %$
+\end{Console}
+%$
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 \itindex{three~way~handshake}
-\textit{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 \textit{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}
+A questo punto si può lanciare il client, esso chiamerà \func{socket} e
+\func{connect}; una volta completato il \textit{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 \textit{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{Terminal}
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}
+\end{Terminal}
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}
+ \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}
+\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
+\begin{Console}
+[piccardi@roke piccardi]$ \textbf{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} %$
+\end{Console}
+%$
(dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di
tre processi, tutti in stato di \textit{sleep} (vedi
tab.~\ref{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 sez.~\ref{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.
+Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso
+niente fintanto che non si preme il tasto di a capo (si ricordi quanto detto
+in sez.~\ref{sec:file_line_io} a proposito dell'I/O su terminale). Solo
+allora \func{fgets} ritornerà ed il client scriverà quanto immesso dal
+terminale sul socket, per poi passare a rileggere quanto gli viene inviato
+all'indietro dal server, che a sua volta sarà inviato sullo \textit{standard
+ output}, che nel caso ne provoca l'immediata stampa a video.
\subsection{La conclusione normale}
\label{sec:TCP_echo_conclusion}
-Tutto quello che scriveremo sul client sarà rimandato indietro dal server e
+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
+sessione tipica sarà allora del tipo:
+\begin{Console}
+[piccardi@roke sources]$ \textbf{./echo 127.0.0.1}
Questa e` una prova
Questa e` una prova
Ho finito
Ho finito
-\end{verbatim} %$
+\end{Console}
+%$
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
+\begin{Console}
+[piccardi@roke piccardi]$ \textbf{netstat -at}
tcp 0 0 *:echo *:* LISTEN
tcp 0 0 localhost:33032 localhost:echo TIME_WAIT
-\end{verbatim} %$
+\end{Console}
+%$
con il client che entra in \texttt{TIME\_WAIT}.
Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
-terminazione normale della connessione, che ci servirà poi da riferimento
+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.
+ 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
+ come parte del processo di terminazione tutti i file descriptor vengono chiusi
(si ricordi quanto detto in sez.~\ref{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
+ 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
sez.~\ref{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
+ 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
+ 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}
\subsection{La gestione dei processi figli}
\label{sec:TCP_child_hand}
-Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto
+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 sez.~\ref{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
+del segnale \signal{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 sez.~\ref{sec:sig_sigchld}), come risulterà
+otterremo che il processo figlio entrerà nello stato di \textit{zombie} (si
+riveda quanto illustrato in sez.~\ref{sec:sig_sigchld}), come risulterà
ripetendo il comando \cmd{ps}:
-\begin{verbatim}
+\begin{Terminal}
2356 pts/0 S 0:00 ./echod
2359 pts/0 Z 0:00 [echod <defunct>]
-\end{verbatim}
+\end{Terminal}
-Dato che non è il caso di lasciare processi zombie\index{zombie}, occorrerà
+Dato che non è il caso di lasciare processi \textit{zombie}, occorrerà
ricevere opportunamente lo stato di terminazione del processo (si veda
-sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \const{SIGCHLD} secondo
-quanto illustrato in sez.~\ref{sec:sig_sigchld}. Una prima modifica al nostro
-server è pertanto quella di inserire la gestione della terminazione dei
+sez.~\ref{sec:proc_wait}), cosa che faremo utilizzando \signal{SIGCHLD}
+secondo quanto illustrato in sez.~\ref{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 fig.~\ref{fig:sig_Signal_code}), per
-installare il gestore che riceve i segnali dei processi figli terminati già
-visto in fig.~\ref{fig:sig_sigchld_handl}. Basterà allora aggiungere il
+installare il gestore che riceve i segnali dei processi figli terminati già
+visto in fig.~\ref{fig:sig_sigchld_handl}. Basterà allora aggiungere il
seguente codice: \includecodesnip{listati/sigchildhand.c}
\noindent
all'esempio illustrato in fig.~\ref{fig:TCP_echo_server_first_code}.
-In questo modo però si introduce un altro problema. Si ricordi infatti che,
+In questo modo però si introduce un altro problema. Si ricordi infatti che,
come spiegato in sez.~\ref{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}.
+stato di \texttt{sleep} durante l'esecuzione di una \textit{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 \textit{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
+client, il processo figlio che gestisce la connessione terminerà, ed il padre,
+per evitare la creazione di \textit{zombie}, riceverà il segnale
+\signal{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{Console}
+[root@gont sources]# \textbf{./echod -i}
accept error: Interrupted system call
-\end{verbatim}%#
+\end{Console}
Come accennato in sez.~\ref{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 fig.~\ref{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
+comportamento delle \textit{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 \textit{system call} interrotte secondo
+la semantica di BSD, usando l'opzione \const{SA\_RESTART} di \func{sigaction};
+rispetto a quanto visto in fig.~\ref{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 fig.~\ref{fig:sig_SignalRestart_code}, ed
installeremo il gestore usando quest'ultima.
-\begin{figure}[!htb]
- \footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+\begin{figure}[!htbp]
+ \footnotesize \centering
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/SignalRestart.c}
\end{minipage}
\normalsize
\caption{La funzione \func{SignalRestart}, che installa un gestore di
- segnali in semantica BSD per il riavvio automatico delle system call
- interrotte.}
+ segnali in semantica BSD per il riavvio automatico delle \textit{system
+ call} interrotte.}
\label{fig:sig_SignalRestart_code}
\end{figure}
-Come si può notare questa funzione è identica alla precedente \func{Signal},
-illustrata in fig.~\ref{fig:sig_Signal_code}, solo che in questo caso invece di
-inizializzare a zero il campo \var{sa\_flags} di \struct{sigaction}, lo si
+Come si può notare questa funzione è identica alla precedente \func{Signal},
+illustrata in fig.~\ref{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
+funzione al posto di \func{Signal} nel server non è necessaria nessuna altra
+modifica: le \textit{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 \textit{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 \textit{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, è
+introdotte una serie di nuove opzioni che ci saranno utili per il debug, è
mostrata in fig.~\ref{fig:TCP_echo_server_code_second}, dove si sono riportate
la sezioni di codice modificate nella seconda versione del programma, il
codice completo di quest'ultimo si trova nel file
\texttt{TCP\_echod\_second.c} dei sorgenti allegati alla guida.
-La prima modifica effettuata è stata quella di introdurre una nuova opzione a
+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.
+compatibile nella gestione di \signal{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
+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
+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
+nullo la variabile \var{debugging}. Al solito si è omessa da
fig.~\ref{fig:TCP_echo_server_code_second} la sezione di codice relativa alla
-gestione di tutte queste opzioni, che può essere trovata nel sorgente del
+gestione di tutte queste opzioni, che può essere trovata nel sorgente del
programma.
-\begin{figure}[!htb]
+\begin{figure}[!htb ]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\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.}
+ delle \textit{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
+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 \signal{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
+amministratore ed eventualmente lancia il programma come demone, è rimasta
+invariata e pertanto è stata omessa in
fig.~\ref{fig:TCP_echo_server_code_second}; l'unica modifica effettuata prima
-dell'entrata nel ciclo principale è stata quella di aver introdotto, subito
+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 \texttt{-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 lenta, 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
-\index{system~call~lente} \textit{slow system call}\footnote{si ricordi la
- distinzione fatta in sez.~\ref{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}.
+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 \textit{system call} lenta, che può
+essere interrotta dall'arrivo di \signal{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{system call} lente (si ricordi la distinzione fatta in
+sez.~\ref{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 \signal{SIGCHLD}.
Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small
23--42}), rispetto precedente versione di fig.~\ref{fig:TCP_ServEcho_first},
-è nella sezione (\texttt{\small 25--31}) in cui si effettua la chiamata di
+è nella sezione (\texttt{\small 25--31}) 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 è
+ 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
+ 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 32--40}) di aiuto per il debug del programma, che eseguita con
-un controllo (\texttt{\small 33}) sul valore della variabile \var{debugging}
-impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come
-preimpostato, non accade nulla. altrimenti (\texttt{\small 33}) l'indirizzo
-ricevuto da \var{accept} viene convertito in una stringa che poi
-(\texttt{\small 34--39}) viene opportunamente stampata o sullo schermo o nei
-log.
-
-Infine come ulteriore miglioria si è perfezionata la funzione \code{ServEcho},
-sia per tenere conto della nuova funzionalità di debugging, che per effettuare
-un controllo in caso di errore; il codice della nuova versione è mostrato in
-fig.~\ref{fig:TCP_ServEcho_second}.
-
-\begin{figure}[!htb]
+\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ServEcho_second.c}
\end{minipage}
\normalsize
\label{fig:TCP_ServEcho_second}
\end{figure}
-Rispetto alla precedente versione di fig.~\ref{fig:TCP_ServEcho_first} in
-questo caso si è provveduto a controllare (\texttt{\small 7--10}) il valore di
+Si noti che in questa nuova versione si è aggiunta una ulteriore sezione
+(\texttt{\small 32--40}) di aiuto per il debug del programma, che eseguita con
+un controllo (\texttt{\small 33}) sul valore della variabile \var{debugging}
+impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come
+preimpostato, non accade nulla, altrimenti (\texttt{\small 33}) l'indirizzo
+ricevuto da \var{accept} viene convertito in una stringa che poi
+(\texttt{\small 34--39}) viene opportunamente stampata o sullo schermo o nei
+log.
+
+Infine come ulteriore miglioria si è perfezionata la funzione \code{ServEcho},
+sia per tenere conto della nuova funzionalità di debugging, che per effettuare
+un controllo in caso di errore; il codice della nuova versione è mostrato in
+fig.~\ref{fig:TCP_ServEcho_second}.
+
+ Rispetto alla precedente versione di fig.~\ref{fig:TCP_ServEcho_first} in
+questo caso si è provveduto a controllare (\texttt{\small 7--10}) il valore di
ritorno di \func{read} per rilevare un eventuale errore, in modo da stampare
(\texttt{\small 8}) un messaggio di errore e ritornare (\texttt{\small 9})
concludendo la connessione.
-Inoltre qualora sia stata attivata la funzionalità di debug (avvalorando
-\var{debugging} tramite l'apposita opzione \texttt{-d}) si provvederà a
-stampare (tenendo conto della modalità di invocazione del server, se
-interattiva o in forma di demone) il numero di byte e la stringa letta dal
-client (\texttt{\small 16--24}).
+Inoltre qualora sia stata attivata la funzionalità di debug (avvalorando
+\var{debugging} tramite l'apposita opzione \texttt{-d}) si provvederà a
+stampare (\texttt{\small 16--24}) il numero di byte e la stringa letta dal
+client, tenendo conto della modalità di invocazione del server, se interattiva
+o in forma di demone.
\section{I vari scenari critici}
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
+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
+La prima situazione critica è quella della terminazione precoce, causata da un
qualche errore sulla rete, della connessione effettuata da un client. Come
accennato in sez.~\ref{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
+\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
+È però possibile, dal punto di vista teorico, incorrere anche in uno scenario
del tipo di quello mostrato in fig.~\ref{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}
+\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
+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 \textit{three
- way handshake}\itindex{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
-fig.~\ref{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
+connessioni è demandata a processi figli, può accadere che il \textit{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 fig.~\ref{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 sez.~\ref{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},
+\signal{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di
+\func{accept}; questi, come nel caso precedente, necessitano semplicemente la
+ripetizione della chiamata senza 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
+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 sez.~\ref{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 (usando l'opzione \const{SO\_LINGER}, vedi
-sez.~\ref{sec:sock_options_main}), non si ha nessun errore al ritorno di
-\func{accept}, quanto un errore di \errcode{ECONNRESET} al primo tentativo di
-accesso al socket.
+\func{accept} ritornerà senza errori, e si avrà semplicemente un
+\textit{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
+RST alla chiusura dal socket (usando l'opzione \const{SO\_LINGER}, vedi
+sez.~\ref{sec:sock_options_main}), non si ha comunque nessun errore al ritorno
+di \func{accept}, quanto un errore di \errcode{ECONNRESET} al primo tentativo
+di accesso al socket.
\subsection{La terminazione precoce del server}
\label{sec:TCP_server_crash}
-Un secondo caso critico è quello in cui si ha una terminazione precoce del
-server, ad esempio perché il programma ha un crash. In tal caso si suppone che
+Un secondo caso critico è quello in cui si ha una terminazione precoce del
+server, ad esempio perché il programma ha un crash. In tal caso si suppone che
il processo 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 descriptor 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
+del servizio il client riceverà un FIN dal server in corrispondenza della
chiusura del socket.
Vediamo allora cosa succede nel nostro caso, facciamo partire una connessione
con il server e scriviamo una prima riga, poi terminiamo il server con un
\texttt{C-c}. A questo punto scriviamo una seconda riga e poi un'altra riga
-ancora. Il risultato finale della sessione è il seguente:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.141
+ancora. Il risultato finale della sessione è il seguente:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
Prima riga
Prima riga
Seconda riga dopo il C-c
Altra riga
[piccardi@gont sources]$
-\end{verbatim}
+\end{Console}
Come si vede il nostro client, nonostante la connessione sia stata interrotta
prima dell'invio della seconda riga, non solo accetta di inviarla, ma prende
anche un'altra riga prima di terminare senza riportare nessun
errore.
-Per capire meglio cosa è successo conviene analizzare il flusso dei pacchetti
+Per capire meglio cosa è successo conviene analizzare il flusso dei pacchetti
utilizzando un analizzatore di traffico come \cmd{tcpdump}. Il comando
permette di selezionare, nel traffico di rete generato su una macchina, i
pacchetti che interessano, stampando a video (o salvando su disco) il loro
contenuto. Non staremo qui ad entrare nei dettagli dell'uso del programma, che
-sono spiegati dalla pagina di manuale; per l'uso che vogliamo farne quello che
-ci interessa è, posizionandosi sulla macchina che fa da client, selezionare
-tutti i pacchetti che sono diretti o provengono dalla macchina che fa da
-server. In questo modo (posto che non ci siano altre connessioni col server,
-cosa che avremo cura di evitare) tutti i pacchetti rilevati apparterranno alla
-nostra sessione di interrogazione del servizio.
+sono spiegati dalla pagina di manuale;\footnote{per una trattazione di base si
+ può consultare sez.~5.2.2 di \cite{SGL}.} per l'uso che vogliamo farne
+quello che ci interessa è, posizionandosi sulla macchina che fa da client,
+selezionare tutti i pacchetti che sono diretti o provengono dalla macchina che
+fa da server. In questo modo (posto che non ci siano altre connessioni col
+server, cosa che avremo cura di evitare) tutti i pacchetti rilevati
+apparterranno alla nostra sessione di interrogazione del servizio.
Il comando \cmd{tcpdump} permette selezioni molto complesse, basate sulle
interfacce su cui passano i pacchetti, sugli indirizzi IP, sulle porte, sulle
Lanciando il comando prima di ripetere la sessione di lavoro mostrata
nell'esempio precedente potremo allora catturare tutti pacchetti scambiati fra
-il client ed il server; i risultati\footnote{in realtà si è ridotta la
- lunghezza dell'output rispetto al reale tagliando alcuni dati non necessari
- alla comprensione del flusso.} prodotti in questa occasione da \cmd{tcpdump}
-sono allora i seguenti:
-\begin{verbatim}
-[root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
+il client ed il server; i risultati (in realtà si è ridotta la lunghezza
+dell'output rispetto al reale tagliando alcuni dati non necessari alla
+comprensione del flusso) prodotti in questa occasione da \cmd{tcpdump} sono
+allora i seguenti:
+\begin{Console}
+[root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
tcpdump: listening on eth0
gont.34559 > anarres.echo: S 800922320:800922320(0) win 5840
anarres.echo > gont.34559: S 511689719:511689719(0) ack 800922321 win 5792
gont.34559 > anarres.echo: . ack 13 win 5840
gont.34559 > anarres.echo: P 12:37(25) ack 13 win 5840
anarres.echo > gont.34559: R 511689732:511689732(0) win 0
-\end{verbatim}
+\end{Console}
Le prime tre righe vengono prodotte al momento in cui lanciamo il nostro
-client, e corrispondono ai tre pacchetti del
-\itindex{three~way~handshake}\textit{three way handshake}. L'output del
-comando riporta anche i numeri di sequenza iniziali, mentre la lettera
-\texttt{S} indica che per quel pacchetto si aveva il SYN flag attivo. Si noti
-come a partire dal secondo pacchetto sia sempre attivo il campo \texttt{ack},
-seguito dal numero di sequenza per il quale si da il ricevuto; quest'ultimo, a
-partire dal terzo pacchetto, viene espresso in forma relativa per maggiore
-compattezza. Il campo \texttt{win} in ogni riga indica la \textit{advertising
- window} di cui parlavamo in sez.~\ref{sec:TCP_TCP_opt}. Allora si può
-verificare dall'output del comando come venga appunto realizzata la sequenza
-di pacchetti descritta in sez.~\ref{sec:TCP_conn_cre}: prima viene inviato dal
-client un primo pacchetto con il SYN che inizia la connessione, a cui il
-server risponde dando il ricevuto con un secondo pacchetto, che a sua volta
-porta un SYN, cui il client risponde con un il terzo pacchetto di ricevuto.
+client, e corrispondono ai tre pacchetti del \textit{three way handshake}.
+L'output del comando riporta anche i numeri di sequenza iniziali, mentre la
+lettera \texttt{S} indica che per quel pacchetto si aveva il SYN flag attivo.
+Si noti come a partire dal secondo pacchetto sia sempre attivo il campo
+\texttt{ack}, seguito dal numero di sequenza per il quale si da il ricevuto;
+quest'ultimo, a partire dal terzo pacchetto, viene espresso in forma relativa
+per maggiore compattezza. Il campo \texttt{win} in ogni riga indica la
+\textit{advertised window} di cui parlavamo in sez.~\ref{sec:TCP_TCP_opt}.
+
+Allora si può verificare dall'output del comando come venga appunto realizzata
+la sequenza di pacchetti descritta in sez.~\ref{sec:TCP_conn_cre}: prima viene
+inviato dal client un primo pacchetto con il SYN che inizia la connessione, a
+cui il server risponde dando il ricevuto con un secondo pacchetto, che a sua
+volta porta un SYN, cui il client risponde con un il terzo pacchetto di
+ricevuto.
Ritorniamo allora alla nostra sessione con il servizio echo: dopo le tre righe
-del \textit{three way handshake}\itindex{three~way~handshake} non avremo nulla
-fin tanto che non scriveremo una prima riga sul client; al momento in cui
-facciamo questo si genera una sequenza di altri quattro pacchetti. Il primo,
-dal client al server, contraddistinto da una lettera \texttt{P} che significa
-che il flag PSH è impostato, contiene la nostra riga (che è appunto di 11
-caratteri), e ad esso il server risponde immediatamente con un pacchetto vuoto
-di ricevuto. Poi tocca al server riscrivere indietro quanto gli è stato
-inviato, per cui sarà lui a mandare indietro un terzo pacchetto con lo stesso
-contenuto appena ricevuto, e a sua volta riceverà dal client un ACK nel quarto
-pacchetto. Questo causerà la ricezione dell'eco nel client che lo stamperà a
-video.
+del \textit{three way handshake} non avremo nulla fin tanto che non scriveremo
+una prima riga sul client; al momento in cui facciamo questo si genera una
+sequenza di altri quattro pacchetti. Il primo, dal client al server,
+contraddistinto da una lettera \texttt{P} che significa che il flag PSH è
+impostato, contiene la nostra riga (che è appunto di 11 caratteri), e ad esso
+il server risponde immediatamente con un pacchetto vuoto di ricevuto.
+
+Poi tocca al server riscrivere indietro quanto gli è stato inviato, per cui
+sarà lui a mandare indietro un terzo pacchetto con lo stesso contenuto appena
+ricevuto, e a sua volta riceverà dal client un ACK nel quarto pacchetto.
+Questo causerà la ricezione dell'eco nel client che lo stamperà a video.
A questo punto noi procediamo ad interrompere l'esecuzione del server con un
-\texttt{C-c} (cioè con l'invio di \const{SIGTERM}): nel momento in cui
+\texttt{C-c} (cioè con l'invio di \signal{SIGTERM}): nel momento in cui
facciamo questo vengono immediatamente generati altri due pacchetti. La
terminazione del processo infatti comporta la chiusura di tutti i suoi file
descriptor, il che comporta, per il socket che avevamo aperto, l'inizio della
sequenza di chiusura illustrata in sez.~\ref{sec:TCP_conn_term}. Questo
-significa che dal server partirà un FIN, che è appunto il primo dei due
-pacchetti, contraddistinto dalla lettera \texttt{F}, cui seguirà al solito un
+significa che dal server partirà un FIN, che è appunto il primo dei due
+pacchetti, contraddistinto dalla lettera \texttt{F}, cui seguirà al solito un
ACK da parte del client.
-A questo punto la connessione dalla parte del server è chiusa, ed infatti se
+A questo punto la connessione dalla parte del server è chiusa, ed infatti se
usiamo \cmd{netstat} per controllarne lo stato otterremo che sul server si ha:
-\begin{verbatim}
-anarres:/home/piccardi# netstat -ant
+\begin{Console}
+anarres:/home/piccardi# \textbf{netstat -ant}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
... ... ... ... ... ...
tcp 0 0 192.168.1.141:7 192.168.1.2:34626 FIN_WAIT2
-\end{verbatim}
-cioè essa è andata nello stato \texttt{FIN\_WAIT2}, che indica l'avvenuta
-emissione del segmento FIN, mentre sul client otterremo che essa è andata
+\end{Console}
+cioè essa è andata nello stato \texttt{FIN\_WAIT2}, che indica l'avvenuta
+emissione del segmento FIN, mentre sul client otterremo che essa è andata
nello stato \texttt{CLOSE\_WAIT}:
-\begin{verbatim}
-[root@gont gapil]# netstat -ant
+\begin{Console}
+[root@gont gapil]# \textbf{netstat -ant}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
... ... ... ... ... ...
tcp 1 0 192.168.1.2:34582 192.168.1.141:7 CLOSE_WAIT
-\end{verbatim}
+\end{Console}
-Il problema è che in questo momento il client è bloccato dentro la funzione
+Il problema è che in questo momento il client è bloccato dentro la funzione
\texttt{ClientEcho} nella chiamata a \func{fgets}, e sta attendendo dell'input
-dal terminale, per cui non è in grado di accorgersi di nulla. Solo quando
-inseriremo la seconda riga il comando uscirà da \func{fgets} e proverà a
+dal terminale, per cui non è in grado di accorgersi di nulla. Solo quando
+inseriremo la seconda riga il comando uscirà da \func{fgets} e proverà a
scriverla sul socket. Questo comporta la generazione degli ultimi due
pacchetti riportati da \cmd{tcpdump}: il primo, inviato dal client contenente
i 25 caratteri della riga appena letta, e ad esso la macchina server
-risponderà, non essendoci più niente in ascolto sulla porta 7, con un segmento
+risponderà, non essendoci più niente in ascolto sulla porta 7, con un segmento
di RST, contraddistinto dalla lettera \texttt{R}, che causa la conclusione
-definitiva della connessione anche nel client, dove non comparirà più
+definitiva della connessione anche nel client, dove non comparirà più
nell'output di \cmd{netstat}.
-Come abbiamo accennato in sez.~\ref{sec:TCP_conn_term} e come vedremo più
+Come abbiamo accennato in sez.~\ref{sec:TCP_conn_term} e come vedremo più
avanti in sez.~\ref{sec:TCP_shutdown} la chiusura di un solo capo di un socket
-è una operazione lecita, per cui la nostra scrittura avrà comunque successo
-(come si può constatare lanciando usando \cmd{strace}\footnote{il comando
- \cmd{strace} è un comando di debug molto utile che prende come argomento un
- altro comando e ne stampa a video tutte le invocazioni di una system call,
- coi relativi argomenti e valori di ritorno, per cui usandolo in questo
- contesto potremo verificare che effettivamente la \func{write} ha scritto la
- riga, che in effetti è stata pure trasmessa via rete.}), in quanto il nostro
-programma non ha a questo punto alcun modo di sapere che dall'altra parte non
-c'è più nessuno processo in grado di leggere quanto scriverà. Questo sarà
-chiaro solo dopo il tentativo di scrittura, e la ricezione del segmento RST di
-risposta che indica che dall'altra parte non si è semplicemente chiuso un capo
-del socket, ma è completamente terminato il programma.
-
-Per questo motivo il nostro client proseguirà leggendo dal socket, e dato che
-questo è stato chiuso avremo che, come spiegato in
+è una operazione lecita, per cui la nostra scrittura avrà comunque successo
+(come si può constatare lanciando usando \cmd{strace}\footnote{il comando
+ \cmd{strace} è un comando di debug molto utile che prende come argomento un
+ altro comando e ne stampa a video tutte le invocazioni di una \textit{system
+ call}, coi relativi argomenti e valori di ritorno, per cui usandolo in
+ questo contesto potremo verificare che effettivamente la \func{write} ha
+ scritto la riga, che in effetti è stata pure trasmessa via rete.}), in
+quanto il nostro programma non ha a questo punto alcun modo di sapere che
+dall'altra parte non c'è più nessuno processo in grado di leggere quanto
+scriverà. Questo sarà chiaro solo dopo il tentativo di scrittura, e la
+ricezione del segmento RST di risposta che indica che dall'altra parte non si
+è semplicemente chiuso un capo del socket, ma è completamente terminato il
+programma.
+
+Per questo motivo il nostro client proseguirà leggendo dal socket, e dato che
+questo è stato chiuso avremo che, come spiegato in
sez.~\ref{sec:TCP_conn_term}, la funzione \func{read} ritorna normalmente con
un valore nullo. Questo comporta che la seguente chiamata a \func{fputs} non
ha effetto (viene stampata una stringa nulla) ed il client si blocca di nuovo
nella successiva chiamata a \func{fgets}. Per questo diventa possibile
-inserire una terza riga e solo dopo averlo fatto si avrà la terminazione del
+inserire una terza riga e solo dopo averlo fatto si avrà la terminazione del
programma.
Per capire come questa avvenga comunque, non avendo inserito nel codice nessun
-controllo di errore, occorre ricordare che, a parte la bidirezionalità del
+controllo di errore, occorre ricordare che, a parte la bidirezionalità del
flusso dei dati, dal punto di vista del funzionamento nei confronti delle
funzioni di lettura e scrittura, i socket sono del tutto analoghi a delle
-pipe. Allora, da quanto illustrato in sez.~\ref{sec:ipc_pipes}, sappiamo che
-tutte le volte che si cerca di scrivere su una pipe il cui altro capo non è
-aperto il lettura il processo riceve un segnale di \const{SIGPIPE}, e questo è
-esattamente quello che avviene in questo caso, e siccome non abbiamo un
-gestore per questo segnale, viene eseguita l'azione preimpostata, che è quella
-di terminare il processo.
-
-Per gestire in maniera più corretta questo tipo di evento dovremo allora
-modificare il nostro client perché sia in grado di trattare le varie tipologie
+\textit{pipe}. Allora, da quanto illustrato in sez.~\ref{sec:ipc_pipes},
+sappiamo che tutte le volte che si cerca di scrivere su una \textit{pipe} il
+cui altro capo non è aperto il lettura il processo riceve un segnale di
+\signal{SIGPIPE}, e questo è esattamente quello che avviene in questo caso, e
+siccome non abbiamo un gestore per questo segnale, viene eseguita l'azione
+preimpostata, che è quella di terminare il processo.
+
+Per gestire in maniera più corretta questo tipo di evento dovremo allora
+modificare il nostro client perché sia in grado di trattare le varie tipologie
di errore, per questo dovremo riscrivere la funzione \func{ClientEcho}, in
-modo da controllare gli stati di uscita delle varie chiamate. Si è riportata
+modo da controllare gli stati di uscita delle varie chiamate. Si è riportata
la nuova versione della funzione in fig.~\ref{fig:TCP_ClientEcho_second}.
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ClientEcho_second.c}
\end{minipage}
\normalsize
\label{fig:TCP_ClientEcho_second}
\end{figure}
-Come si può vedere in questo caso si controlla il valore di ritorno di tutte
-le funzioni, ed inoltre si verifica la presenza di un eventuale end of file in
-caso di lettura. Con questa modifica il nostro client echo diventa in grado di
-accorgersi della chiusura del socket da parte del server, per cui ripetendo la
-sequenza di operazioni precedenti stavolta otterremo che:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.141
+Come si può vedere in questo caso si controlla il valore di ritorno di tutte
+le funzioni, ed inoltre si verifica la presenza di un eventuale
+\textit{end-of-file} in caso di lettura. Con questa modifica il nostro client
+\cmd{echo} diventa in grado di accorgersi della chiusura del socket da parte
+del server, per cui ripetendo la sequenza di operazioni precedenti stavolta
+otterremo che:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
Prima riga
Prima riga
Seconda riga dopo il C-c
EOF sul socket
-\end{verbatim}%$
-ma di nuovo si tenga presente che non c'è modo di accorgersi della chiusura
+\end{Console}
+%$
+ma di nuovo si tenga presente che non c'è modo di accorgersi della chiusura
del socket fin quando non si esegue la scrittura della seconda riga; il
protocollo infatti prevede che ci debba essere una scrittura prima di ricevere
un RST che confermi la chiusura del file, e solo alle successive scritture si
-potrà ottenere un errore.
+potrà ottenere un errore.
Questa caratteristica dei socket ci mette di fronte ad un altro problema
-relativo al nostro client, e che cioè esso non è in grado di accorgersi di
-nulla fintanto che è bloccato nella lettura del terminale fatta con
-\func{gets}. In questo caso il problema è minimo, ma esso riemergerà più
-avanti, ed è quello che si deve affrontare tutte le volte quando si ha a che
-fare con la necessità di lavorare con più descrittori, nel qual caso diventa
-si pone la questione di come fare a non restare bloccati su un socket quando
-altri potrebbero essere liberi. Vedremo come affrontare questa problematica in
+relativo al nostro client, e che cioè esso non è in grado di accorgersi di
+nulla fintanto che è bloccato nella lettura del terminale fatta con
+\func{gets}. In questo caso il problema è minimo, ma esso riemergerà più
+avanti, ed è quello che si deve affrontare tutte le volte quando si ha a che
+fare con la necessità di lavorare con più descrittori, nel qual caso si pone
+la questione di come fare a non restare bloccati su un socket quando altri
+potrebbero essere liberi. Vedremo come affrontare questa problematica in
sez.~\ref{sec:TCP_sock_multiplexing}.
\subsection{Altri scenari di terminazione della connessione}
\label{sec:TCP_conn_crash}
-La terminazione del server è solo uno dei possibili scenari di terminazione
-della connessione, un altro caso è ad esempio quello in cui si ha un crollo
-della rete, cosa che potremo simulare facilmente staccando il cavo di rete.
-Un'altra condizione è quella di un blocco della macchina completo della su cui
-gira il server che deve essere riavviata, cosa che potremo simulare sia
-premendo il bottone di reset,\footnote{un normale shutdown non va bene; in tal
- caso infatti il sistema provvede a terminare tutti i processi, per cui la
- situazione sarebbe sostanzialmente identica alla precedente.} che, in
-maniera più gentile, riavviando la macchina dopo aver interrotto la
+La terminazione del server è solo uno dei possibili scenari di terminazione
+della connessione, un altro caso è ad esempio quello in cui si ha
+un'interruzione sulla rete, cosa che potremo simulare facilmente staccando il
+cavo di rete. Un'altra condizione è quella di un blocco completo della
+macchina su cui gira il server che deve essere riavviata, cosa che potremo
+simulare sia eseguendo un reset fisico (un normale shutdown non va bene; in
+tal caso infatti il sistema provvede a terminare tutti i processi, per cui la
+situazione sarebbe sostanzialmente identica alla precedente) oppure, in
+maniera più gentile, riavviando la macchina dopo aver interrotto la
connessione di rete.
-Cominciamo ad analizzare il primo caso, il crollo della rete. Ripetiamo la
-nostra sessione di lavoro precedente, lanciamo il client, scriviamo una prima
-riga, poi stacchiamo il cavo e scriviamo una seconda riga. Il risultato che
-otterremo è:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.141
+Cominciamo ad analizzare il primo caso, l'interruzione del collegamento di
+rete. Ripetiamo la nostra sessione di lavoro precedente, lanciamo il client,
+scriviamo una prima riga, poi stacchiamo il cavo e scriviamo una seconda
+riga. Il risultato che otterremo è:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
Prima riga
Prima riga
Seconda riga dopo l'interruzione
Errore in lettura: No route to host
-\end{verbatim}%$
+\end{Console}
+%$
-Quello che succede in questo è che il programma, dopo aver scritto la seconda
+Quello che succede in questo è che il programma, dopo aver scritto la seconda
riga, resta bloccato per un tempo molto lungo, prima di dare l'errore
\errcode{EHOSTUNREACH}. Se andiamo ad osservare con \cmd{strace} cosa accade
-nel periodo in cui il programma è bloccato vedremo che stavolta, a differenza
-del caso precedente, il programma è bloccato nella lettura dal socket.
+nel periodo in cui il programma è bloccato vedremo che stavolta, a differenza
+del caso precedente, il programma è bloccato nella lettura dal socket.
Se poi, come nel caso precedente, usiamo l'accortezza di analizzare il
traffico di rete fra client e server con \cmd{tcpdump}, otterremo il seguente
risultato:
-\begin{verbatim}
-[root@gont sources]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
+\begin{Console}
+[root@gont sources]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
tcpdump: listening on eth0
gont.34685 > anarres.echo: S 1943495663:1943495663(0) win 5840
anarres.echo > gont.34685: S 1215783131:1215783131(0) ack 1943495664 win 5792
arp who-has anarres tell gont
arp who-has anarres tell gont
...
-\end{verbatim}
+\end{Console}
-In questo caso l'andamento dei primi sette pacchetti è esattamente lo stesso
+In questo caso l'andamento dei primi sette pacchetti è esattamente lo stesso
di prima. Solo che stavolta, non appena inviata la seconda riga, il programma
-si bloccherà nella successiva chiamata a \func{read}, non ottendo nessuna
-risposta. Quello che succede è che nel frattempo il kernel provvede, come
+si bloccherà nella successiva chiamata a \func{read}, non ottenendo nessuna
+risposta. Quello che succede è che nel frattempo il kernel provvede, come
richiesto dal protocollo TCP, a tentare la ritrasmissione della nostra riga un
certo numero di volte, con tempi di attesa crescente fra un tentativo ed il
successivo, per tentare di ristabilire la connessione.
-Il risultato finale qui dipende dall'implementazione dello stack TCP, e nel
-caso di Linux anche dall'impostazione di alcuni dei parametri di sistema che
-si trovano in \file{/proc/sys/net/ipv4}, che ne controllano il comportamento:
-in questo caso in particolare da \file{tcp\_retries2} (vedi
-sez.~\ref{sec:sock_sysctl}). Questo parametro infatti specifica il numero di
-volte che deve essere ritentata la ritrasmissione di un pacchetto nel mezzo di
-una connessione prima di riportare un errore di timeout. Il valore
-preimpostato è pari a 15, il che comporterebbe 15 tentativi di ritrasmissione,
+Il risultato finale qui dipende dalla realizzazione dello \textit{stack TCP},
+e nel caso di Linux anche dall'impostazione di alcuni dei parametri di sistema
+che si trovano in \file{/proc/sys/net/ipv4}, che ne controllano il
+comportamento: in questo caso in particolare da
+\sysctlrelfile{net/ipv4}{tcp\_retries2} (vedi
+sez.~\ref{sec:sock_ipv4_sysctl}). Questo parametro infatti specifica il numero
+di volte che deve essere ritentata la ritrasmissione di un pacchetto nel mezzo
+di una connessione prima di riportare un errore di timeout. Il valore
+preimpostato è pari a 15, il che comporterebbe 15 tentativi di ritrasmissione,
ma nel nostro caso le cose sono andate diversamente, dato che le
ritrasmissioni registrate da \cmd{tcpdump} sono solo 8; inoltre l'errore
-riportato all'uscita del client non è stato \errcode{ETIMEDOUT}, come dovrebbe
+riportato all'uscita del client non è stato \errcode{ETIMEDOUT}, come dovrebbe
essere in questo caso, ma \errcode{EHOSTUNREACH}.
Per capire l'accaduto continuiamo ad analizzare l'output di \cmd{tcpdump}:
pacchetto sono cessati, per essere sostituiti da una serie di richieste di
protocollo ARP in cui il client richiede l'indirizzo del server.
-Come abbiamo accennato in sez.~\ref{sec:net_tcpip_general} ARP è il protocollo
+Come abbiamo accennato in sez.~\ref{sec:net_tcpip_general} ARP è il protocollo
che si incarica di trovare le corrispondenze fra indirizzo IP e indirizzo
-hardware sulla scheda di rete. È evidente allora che nel nostro caso, essendo
-client e server sulla stessa rete, è scaduta la voce nella \textit{ARP
- cache}\footnote{la \textit{ARP chache} è una tabella mantenuta internamente
+hardware sulla scheda di rete. È evidente allora che nel nostro caso, essendo
+client e server sulla stessa rete, è scaduta la voce nella \textit{ARP
+ cache}\footnote{la \textit{ARP cache} è una tabella mantenuta internamente
dal kernel che contiene tutte le corrispondenze fra indirizzi IP e indirizzi
fisici, ottenute appunto attraverso il protocollo ARP; le voci della tabella
hanno un tempo di vita limitato, passato il quale scadono e devono essere
iniziato ad effettuare richieste ARP sulla rete per sapere l'IP di
quest'ultimo, che essendo scollegato non poteva rispondere. Anche per questo
tipo di richieste esiste un timeout, per cui dopo un certo numero di tentativi
-il meccanismo si è interrotto, e l'errore riportato al programma a questo
-punto è stato \errcode{EHOSTUNREACH}, in quanto non si era più in grado di
+il meccanismo si è interrotto, e l'errore riportato al programma a questo
+punto è stato \errcode{EHOSTUNREACH}, in quanto non si era più in grado di
contattare il server.
-Un altro errore possibile in questo tipo di situazione, che si può avere
-quando la macchina è su una rete remota, è \errcode{ENETUNREACH}; esso viene
+Un altro errore possibile in questo tipo di situazione, che si può avere
+quando la macchina è su una rete remota, è \errcode{ENETUNREACH}; esso viene
riportato alla ricezione di un pacchetto ICMP di \textit{destination
unreachable} da parte del router che individua l'interruzione della
-connessione. Di nuovo anche qui il risultato finale dipende da quale è il
-meccanismo più veloce ad accorgersi del problema.
+connessione. Di nuovo anche qui il risultato finale dipende da quale è il
+meccanismo più veloce che porta ad accorgersi del problema.
-Se però agiamo sui parametri del kernel, e scriviamo in \file{tcp\_retries2}
-un valore di tentativi più basso, possiamo evitare la scadenza della
-\textit{ARP cache} e vedere cosa succede. Così se ad esempio richiediamo 4
-tentativi di ritrasmissione, l'analisi di \cmd{tcpdump} ci riporterà il
+Se però agiamo sui parametri del kernel, e scriviamo in \file{tcp\_retries2}
+un valore di tentativi più basso, possiamo evitare la scadenza della
+\textit{ARP cache} e vedere cosa succede. Così se ad esempio richiediamo 4
+tentativi di ritrasmissione, l'analisi di \cmd{tcpdump} ci riporterà il
seguente scambio di pacchetti:
-\begin{verbatim}
-[root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
+\begin{Console}
+[root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
tcpdump: listening on eth0
gont.34752 > anarres.echo: S 3646972152:3646972152(0) win 5840
anarres.echo > gont.34752: S 2735190336:2735190336(0) ack 3646972153 win 5792
gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840
gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840
gont.34752 > anarres.echo: P 12:45(33) ack 12 win 5840
-\end{verbatim}
+\end{Console}
e come si vede in questo caso i tentativi di ritrasmissione del pacchetto
iniziale sono proprio 4 (per un totale di 5 voci con quello trasmesso la prima
-volta), ed in effetti, dopo un tempo molto più breve rispetto a prima ed in
+volta), ed in effetti, dopo un tempo molto più breve rispetto a prima ed in
corrispondenza dell'invio dell'ultimo tentativo, quello che otterremo come
-errore all'uscita del client sarà diverso, e cioè:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.141
+errore all'uscita del client sarà diverso, e cioè:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
Prima riga
Prima riga
Seconda riga dopo l'interruzione
Errore in lettura: Connection timed out
-\end{verbatim}%$
+\end{Console}
+%$
che corrisponde appunto, come ci aspettavamo, alla ricezione di un
\errcode{ETIMEDOUT}.
fa da server. Al solito lanciamo il nostro client, scriviamo una prima riga
per verificare che sia tutto a posto, poi stacchiamo il cavo e riavviamo il
server. A questo punto, ritornato attivo il server, scriviamo una seconda
-riga. Quello che otterremo in questo caso è:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.141
+riga. Quello che otterremo in questo caso è:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.141}
Prima riga
Prima riga
Seconda riga dopo l'interruzione
Errore in lettura Connection reset by peer
-\end{verbatim}%$
-e l'errore ricevuti da \func{read} stavolta è \errcode{ECONNRESET}. Se al
+\end{Console}
+%$
+e l'errore ricevuti da \func{read} stavolta è \errcode{ECONNRESET}. Se al
solito riportiamo l'analisi dei pacchetti effettuata con \cmd{tcpdump},
avremo:
-\begin{verbatim}
-[root@gont gapil]# tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t
+\begin{Console}
+[root@gont gapil]# \textbf{tcpdump src 192.168.1.141 or dst 192.168.1.141 -N -t}
tcpdump: listening on eth0
gont.34756 > anarres.echo: S 904864257:904864257(0) win 5840
anarres.echo > gont.34756: S 4254564871:4254564871(0) ack 904864258 win 5792
gont.34756 > anarres.echo: . ack 12 win 5840
gont.34756 > anarres.echo: P 12:45(33) ack 12 win 5840
anarres.echo > gont.34756: R 4254564883:4254564883(0) win 0
-\end{verbatim}
+\end{Console}
Ancora una volta i primi sette pacchetti sono gli stessi; ma in questo caso
-quello che succede dopo lo scambio iniziale è che, non avendo inviato nulla
-durante il periodo in cui si è riavviato il server, il client è del tutto
-ignaro dell'accaduto per cui quando effettuerà una scrittura, dato che la
-macchina server è stata riavviata e che tutti gli stati relativi alle
+quello che succede dopo lo scambio iniziale è che, non avendo inviato nulla
+durante il periodo in cui si è riavviato il server, il client è del tutto
+ignaro dell'accaduto per cui quando effettuerà una scrittura, dato che la
+macchina server è stata riavviata e che tutti gli stati relativi alle
precedenti connessioni sono completamente persi, anche in presenza di una
-nuova istanza del server echo non sarà possibile consegnare i dati in arrivo,
-per cui alla loro ricezione il kernel risponderà con un segmento di RST.
+nuova istanza del server echo non sarà possibile consegnare i dati in arrivo,
+per cui alla loro ricezione il kernel risponderà con un segmento di RST.
-Il client da parte sua, dato che neanche in questo caso non è stato emesso un
-FIN, dopo aver scritto verrà bloccato nella successiva chiamata a \func{read},
-che però adesso ritornerà immediatamente alla ricezione del segmento RST,
+Il client da parte sua, dato che neanche in questo caso non è stato emesso un
+FIN, dopo aver scritto verrà bloccato nella successiva chiamata a \func{read},
+che però adesso ritornerà immediatamente alla ricezione del segmento RST,
riportando appunto come errore \errcode{ECONNRESET}. Occorre precisare che se
si vuole che il client sia in grado di accorgersi del crollo del server anche
-quando non sta effettuando uno scambio di dati, è possibile usare una
+quando non sta effettuando uno scambio di dati, è possibile usare una
impostazione speciale del socket (ci torneremo in
sez.~\ref{sec:sock_generic_options}) che provvede all'esecuzione di questo
controllo.
-\section{L'uso dell'I/O multiplexing}
+
+\section{L'uso dell'\textit{I/O multiplexing}}
\label{sec:TCP_sock_multiplexing}
-Affronteremo in questa sezione l'utilizzo dell'I/O multiplexing, affrontato in
-sez.~\ref{sec:file_multiplexing}, nell'ambito delle applicazioni di rete. Già
-in sez.~\ref{sec:TCP_server_crash} era emerso il problema relativo al client
-del servizio echo che non era in grado di accorgersi della terminazione
-precoce del server, essendo bloccato nella lettura dei dati immessi da
-tastiera.
+Affronteremo in questa sezione l'utilizzo dell'\textit{I/O multiplexing},
+affrontato in sez.~\ref{sec:file_multiplexing}, nell'ambito delle applicazioni
+di rete. Già in sez.~\ref{sec:TCP_server_crash} era emerso il problema
+relativo al client del servizio \textit{echo} che non era in grado di
+accorgersi della terminazione precoce del server, essendo bloccato nella
+lettura dei dati immessi da tastiera.
-Abbiamo visto in sez.~\ref{sec:file_multiplexing} quali sono le funzionalità
-del sistema che ci permettono di tenere sotto controllo più file descriptor in
+Abbiamo visto in sez.~\ref{sec:file_multiplexing} quali sono le funzionalità
+del sistema che ci permettono di tenere sotto controllo più file descriptor in
contemporanea; in quella occasione non abbiamo fatto esempi, in quanto quando
si tratta con file normali questa tipologia di I/O normalmente non viene
-usata, è invece un caso tipico delle applicazioni di rete quello di dover
+usata, è invece un caso tipico delle applicazioni di rete quello di dover
gestire varie connessioni da cui possono arrivare dati comuni in maniera
asincrona, per cui riprenderemo l'argomento in questa sezione.
\subsection{Il comportamento della funzione \func{select} con i socket.}
\label{sec:TCP_sock_select}
-Iniziamo con la prima delle funzioni usate per l'I/O multiplexing,
-\func{select}; il suo funzionamento è già stato descritto in dettaglio in
-sez.~\ref{sec:file_multiplexing} e non staremo a ripetere quanto detto lì;
-sappiamo che la funzione ritorna quando uno o più dei file descriptor messi
-sotto controllo è pronto per la relativa operazione.
-
-In quell'occasione non abbiamo però definito cosa si intende per pronto,
-infatti per dei normali file, o anche per delle pipe, la condizione di essere
-pronti per la lettura o la scrittura è ovvia; invece lo è molto meno nel caso
-dei socket, visto che possono intervenire tutte una serie di possibili
-condizioni di errore dovute alla rete. Occorre allora specificare chiaramente
-quali sono le condizioni per cui un socket risulta essere ``\textsl{pronto}''
-quando viene passato come membro di uno dei tre \textit{file descriptor set}
-usati da \func{select}.
+Iniziamo con la prima delle funzioni usate per l'\textit{I/O multiplexing},
+\func{select}; il suo funzionamento è già stato descritto in dettaglio in
+sez.~\ref{sec:file_multiplexing} e non staremo a ripetere quanto detto lì;
+sappiamo che la funzione ritorna quando uno o più dei file descriptor messi
+sotto controllo è pronto per la relativa operazione.
+
+In quell'occasione non abbiamo però definito cosa si intende per pronto,
+infatti per dei normali file, o anche per delle \textit{pipe}, la condizione
+di essere pronti per la lettura o la scrittura è ovvia; invece lo è molto meno
+nel caso dei socket, visto che possono intervenire tutte una serie di
+possibili condizioni di errore dovute alla rete. Occorre allora specificare
+chiaramente quali sono le condizioni per cui un socket risulta essere
+``\textsl{pronto}'' quando viene passato come membro di uno dei tre
+\textit{file descriptor set} usati da \func{select}.
Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
-che un socket (che sarà riportato nel primo insieme di file descriptor) è
+che un socket (che sarà riportato nel primo insieme di file descriptor) è
pronto per la lettura sono le seguenti:
\begin{itemize*}
-\item nel buffer di ricezione del socket sono arrivati dei dati in quantità
+\item nel buffer di ricezione del socket sono arrivati dei dati in quantità
sufficiente a superare il valore di una \textsl{soglia di basso livello} (il
- cosiddetto \textit{low watermark}). Questo valore è espresso in numero di
- byte e può essere impostato con l'opzione del socket \const{SO\_RCVLOWAT}
+ cosiddetto \textit{low watermark}). Questo valore è espresso in numero di
+ byte e può essere impostato con l'opzione del socket \const{SO\_RCVLOWAT}
(tratteremo l'uso di questa opzione in sez.~\ref{sec:sock_generic_options});
- il suo valore di default è 1 per i socket TCP e UDP. In questo caso una
- operazione di lettura avrà successo e leggerà un numero di byte maggiore di
+ il suo valore di default è 1 per i socket TCP e UDP. In questo caso una
+ operazione di lettura avrà successo e leggerà un numero di byte maggiore di
zero.
-\item il lato in lettura della connessione è stato chiuso; si è cioè ricevuto
+\item il lato in lettura della connessione è stato chiuso; si è cioè ricevuto
un segmento FIN (si ricordi quanto illustrato in
sez.~\ref{sec:TCP_conn_term}) sulla connessione. In questo caso una
- operazione di lettura avrà successo, ma non risulteranno presenti dati (in
- sostanza \func{read} ritornerà con un valore nullo) per indicare la
- condizione di end-of-file.
-\item c'è stato un errore sul socket. In questo caso una operazione di lettura
- non si bloccherà ma restituirà una condizione di errore (ad esempio
- \func{read} restituirà -1) e imposterà la variabile \var{errno} al relativo
+ operazione di lettura avrà successo, ma non risulteranno presenti dati (in
+ sostanza \func{read} ritornerà con un valore nullo) per indicare la
+ condizione di \textit{end-of-file}.
+\item c'è stato un errore sul socket. In questo caso una operazione di lettura
+ non si bloccherà ma restituirà una condizione di errore (ad esempio
+ \func{read} restituirà $-1$) e imposterà la variabile \var{errno} al relativo
valore. Vedremo in sez.~\ref{sec:sock_generic_options} come sia possibile
- estrarre e cancellare errori pendenti su un socket usando l'opzione
- \const{SO\_ERROR}.
+ estrarre e cancellare gli errori pendenti su un socket senza usare
+ \func{read} usando l'opzione \const{SO\_ERROR}.
\item quando si sta utilizzando un \textit{listening socket} ed ci sono delle
connessioni completate. In questo caso la funzione \func{accept} non si
- bloccherà.\footnote{in realtà questo non è sempre vero, come accennato in
- sez.~\ref{sec:TCP_conn_early_abort} una connessione può essere abortita
- dalla ricezione di un segmento RST una volta che è stata completata,
- allora se questo avviene dopo che \func{select} è ritornata, ma prima
+ bloccherà.\footnote{in realtà questo non è sempre vero, come accennato in
+ sez.~\ref{sec:TCP_conn_early_abort} una connessione può essere abortita
+ dalla ricezione di un segmento RST una volta che è stata completata,
+ allora se questo avviene dopo che \func{select} è ritornata, ma prima
della chiamata ad \func{accept}, quest'ultima, in assenza di altre
- connessioni, potrà bloccarsi.}
+ connessioni, potrà bloccarsi.}
\end{itemize*}
Le condizioni che fanno si che la funzione \func{select} ritorni segnalando
-che un socket (che sarà riportato nel secondo insieme di file descriptor) è
+che un socket (che sarà riportato nel secondo insieme di file descriptor) è
pronto per la scrittura sono le seguenti:
\begin{itemize*}
-\item nel buffer di invio è disponibile una quantità di spazio superiore al
+\item nel buffer di invio è disponibile una quantità di spazio superiore al
valore della \textsl{soglia di basso livello} in scrittura ed inoltre o il
- socket è già connesso o non necessita (ad esempio è UDP) di connessione. Il
- valore della soglia è espresso in numero di byte e può essere impostato con
- l'opzione del socket \const{SO\_SNDLOWAT} (trattata in
- sez.~\ref{sec:sock_generic_options}); il suo valore di default è 2048 per i
+ socket è già connesso o non necessita (ad esempio è UDP) di connessione. Il
+ valore della soglia è espresso in numero di byte e può essere impostato con
+ l'opzione del socket \const{SO\_SNDLOWAT} (trattata in
+ sez.~\ref{sec:sock_generic_options}); il suo valore di default è 2048 per i
socket TCP e UDP. In questo caso una operazione di scrittura non si
- bloccherà e restituirà un valore positivo pari al numero di byte accettati
+ bloccherà e restituirà un valore positivo pari al numero di byte accettati
dal livello di trasporto.
-\item il lato in scrittura della connessione è stato chiuso. In questo caso
- una operazione di scrittura sul socket genererà il segnale \const{SIGPIPE}.
-\item c'è stato un errore sul socket. In questo caso una operazione di
- scrittura non si bloccherà ma restituirà una condizione di errore ed
- imposterà opportunamente la variabile \var{errno}. Vedremo in
+\item il lato in scrittura della connessione è stato chiuso. In questo caso
+ una operazione di scrittura sul socket genererà il segnale \signal{SIGPIPE}.
+\item c'è stato un errore sul socket. In questo caso una operazione di
+ scrittura non si bloccherà ma restituirà una condizione di errore ed
+ imposterà opportunamente la variabile \var{errno}. Vedremo in
sez.~\ref{sec:sock_generic_options} come sia possibile estrarre e cancellare
errori pendenti su un socket usando l'opzione \const{SO\_ERROR}.
\end{itemize*}
-Infine c'è una sola condizione che fa si che \func{select} ritorni segnalando
-che un socket (che sarà riportato nel terzo insieme di file descriptor) ha una
-condizione di eccezione pendente, e cioè la ricezione sul socket di dati
-\textsl{fuori banda} (o \textit{out-of-band}), una caratteristica specifica
+Infine c'è una sola condizione che fa si che \func{select} ritorni segnalando
+che un socket (che sarà riportato nel terzo insieme di file descriptor) ha una
+condizione di eccezione pendente, e cioè la ricezione sul socket di
+\textsl{dati urgenti} (o \textit{out-of-band}), una caratteristica specifica
dei socket TCP su cui torneremo in sez.~\ref{sec:TCP_urgent_data}.
Si noti come nel caso della lettura \func{select} si applichi anche ad
operazioni che non hanno nulla a che fare con l'I/O di dati come il
riconoscimento della presenza di connessioni pronte, in modo da consentire
-anche l'utilizzo di \func{accept} in modalità non bloccante. Si noti infine
+anche l'utilizzo di \func{accept} in modalità non bloccante. Si noti infine
come in caso di errore un socket venga sempre riportato come pronto sia per la
lettura che per la scrittura.
-Lo scopo dei due valori di soglia per i buffer di ricezione e di invio è
-quello di consentire maggiore flessibilità nell'uso di \func{select} da parte
-dei programmi, se infatti si sa che una applicazione non è in grado di fare
-niente fintanto che non può ricevere o inviare una certa quantità di dati, si
+Lo scopo dei due valori di soglia per i buffer di ricezione e di invio è
+quello di consentire maggiore flessibilità nell'uso di \func{select} da parte
+dei programmi, se infatti si sa che una applicazione non è in grado di fare
+niente fintanto che non può ricevere o inviare una certa quantità di dati, si
possono utilizzare questi valori per far si che \func{select} ritorni solo
-quando c'è la certezza di avere dati a sufficienza.\footnote{questo tipo di
- controllo è utile di norma solo per la lettura, in quanto in genere le
- operazioni di scrittura sono già controllate dall'applicazione, che sà
- sempre quanti dati invia, mentre non è detto possa conoscere la quantità di
+quando c'è la certezza di avere dati a sufficienza.\footnote{questo tipo di
+ controllo è utile di norma solo per la lettura, in quanto in genere le
+ operazioni di scrittura sono già controllate dall'applicazione, che sa
+ sempre quanti dati invia, mentre non è detto possa conoscere la quantità di
dati in ricezione; per cui, nella situazione in cui si conosce almeno un
valore minimo, per evitare la penalizzazione dovuta alla ripetizione delle
- operazioni di lettura per accumulare dati sufficienti, si può lasciare al
- kernel il compito di impostare un minimo al di sotto del quale il file
- descriptor, pur avendo disponibili dei dati, non viene dato per pronto in
- lettura.}
+ operazioni di lettura per accumulare dati sufficienti, si può lasciare al
+ kernel il compito di impostare un minimo al di sotto del quale il socket,
+ pur avendo disponibili dei dati, non viene dato per pronto in lettura.}
-\subsection{Un esempio di I/O multiplexing}
+\subsection{Un esempio di \textit{I/O multiplexing}}
\label{sec:TCP_multiplex_example}
-Abbiamo incontrato la problematica tipica che conduce all'uso dell'I/O
-multiplexing nella nostra analisi degli errori in
+Abbiamo incontrato la problematica tipica che conduce all'uso dell'\textit{I/O
+ multiplexing} nella nostra analisi degli errori in
sez.~\ref{sec:TCP_conn_early_abort}, quando il nostro client non era in grado
di rendersi conto di errori sulla connessione essendo impegnato nella attesa
-di dati in ingresso dallo standard input.
-
-In questo caso il problema è quello di dover tenere sotto controllo due
-diversi file descriptor, lo standard input, da cui viene letto il testo che
-vogliamo inviare al server, e il socket connesso con il server su cui detto
-testo sarà scritto e dal quale poi si vorrà ricevere la risposta. L'uso
-dell'I/O multiplexing consente di tenere sotto controllo entrambi, senza
-restare bloccati.
-
-Nel nostro caso quello che ci interessa è non essere bloccati in lettura sullo
-standard input in caso di errori sulla connessione o chiusura della stessa da
-parte del server. Entrambi questi casi possono essere rilevati usando
-\func{select}, per quanto detto in sez.~\ref{sec:TCP_sock_select}, mettendo
-sotto osservazione i file descriptor per la condizione di essere pronti in
-lettura: sia infatti che si ricevano dati, che la connessione sia chiusa
-regolarmente (con la ricezione di un segmento FIN) che si riceva una
-condizione di errore (con un segmento RST) il socket connesso sarà pronto in
-lettura (nell'ultimo caso anche in scrittura, ma questo non è necessario ai
+di dati in ingresso dallo \textit{standard input}.
+
+In questo caso il problema è quello di dover tenere sotto controllo due
+diversi file descriptor, lo \textit{standard input}, da cui viene letto il
+testo che vogliamo inviare al server, e il socket connesso con il server su
+cui detto testo sarà scritto e dal quale poi si vorrà ricevere la
+risposta. L'uso dell'\textit{I/O multiplexing} consente di tenere sotto controllo
+entrambi, senza restare bloccati.
+
+Nel nostro caso quello che ci interessa è non essere bloccati in lettura sullo
+\textit{standard input} in caso di errori sulla connessione o chiusura della
+stessa da parte del server. Entrambi questi casi possono essere rilevati
+usando \func{select}, per quanto detto in sez.~\ref{sec:TCP_sock_select},
+mettendo sotto osservazione i file descriptor per la condizione di essere
+pronti in lettura: sia infatti che si ricevano dati, che la connessione sia
+chiusa regolarmente (con la ricezione di un segmento FIN) che si riceva una
+condizione di errore (con un segmento RST) il socket connesso sarà pronto in
+lettura (nell'ultimo caso anche in scrittura, ma questo non è necessario ai
nostri scopi).
\begin{figure}[!htb]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ClientEcho_third.c}
\end{minipage}
\normalsize
\end{figure}
Riprendiamo allora il codice del client, modificandolo per l'uso di
-\func{select}. Quello che dobbiamo modificare è la funzione \func{ClientEcho}
+\func{select}. Quello che dobbiamo modificare è la funzione \func{ClientEcho}
di fig.~\ref{fig:TCP_ClientEcho_second}, dato che tutto il resto, che riguarda
-le modalità in cui viene stabilita la connessione con il server, resta
+le modalità in cui viene stabilita la connessione con il server, resta
assolutamente identico. La nostra nuova versione di \func{ClientEcho}, la
-terza della serie, è riportata in fig.~\ref{fig:TCP_ClientEcho_third}, il
+terza della serie, è riportata in fig.~\ref{fig:TCP_ClientEcho_third}, il
codice completo si trova nel file \file{TCP\_echo\_third.c} dei sorgenti
allegati alla guida.
In questo caso la funzione comincia (\texttt{\small 8--9}) con l'azzeramento
-del file descriptor set \var{fset} e l'impostazione del valore \var{maxfd}, da
-passare a \func{select} come massimo per il numero di file descriptor. Per
-determinare quest'ultimo si usa la macro \code{max} definita nel nostro file
-\file{macro.h} che raccoglie una collezione di macro di preprocessore di varia
-utilità.
+del \textit{file descriptor set} \var{fset} e l'impostazione del valore
+\var{maxfd}, da passare a \func{select} come massimo per il numero di file
+descriptor. Per determinare quest'ultimo si usa la macro \code{max} definita
+nel nostro file \file{macro.h} che raccoglie una collezione di macro di
+preprocessore di varia utilità.
La funzione prosegue poi (\texttt{\small 10--41}) con il ciclo principale, che
viene ripetuto indefinitamente. Per ogni ciclo si reinizializza
-(\texttt{\small 11--12}) il file descriptor set, impostando i valori per il
-file descriptor associato al socket \var{socket} e per lo standard input (il
-cui valore si recupera con la funzione \func{fileno}). Questo è necessario in
-quanto la successiva (\texttt{\small 13}) chiamata a \func{select} comporta
-una modifica dei due bit relativi, che quindi devono essere reimpostati
-all'inizio di ogni ciclo.
+(\texttt{\small 11--12}) il \textit{file descriptor set}, impostando i valori
+per il file descriptor associato al socket \var{socket} e per lo
+\textit{standard input} (il cui valore si recupera con la funzione
+\func{fileno}). Questo è necessario in quanto la successiva (\texttt{\small
+ 13}) chiamata a \func{select} comporta una modifica dei due bit relativia
+questi file, che quindi devono essere reimpostati all'inizio di ogni ciclo.
Si noti come la chiamata a \func{select} venga eseguita usando come primo
argomento il valore di \var{maxfd}, precedentemente calcolato, e passando poi
-il solo file descriptor set per il controllo dell'attività in lettura, negli
-altri argomenti sono passati tutti puntatori nulli, non interessando né il
-controllo delle altre attività, né l'impostazione di un valore di timeout.
+il solo \textit{file descriptor set} per il controllo dell'attività in
+lettura, negli altri argomenti vengono passati tutti puntatori nulli, non
+interessando in questo caso né il controllo delle altre attività, né
+l'impostazione di un valore di timeout.
Al ritorno di \func{select} si provvede a controllare quale dei due file
-descriptor presenta attività in lettura, cominciando (\texttt{\small 14--24})
-con il file descriptor associato allo standard input. In caso di attività
-(quando cioè \macro{FD\_ISSET} ritorna una valore diverso da zero) si esegue
-(\texttt{\small 15}) una \func{fgets} per leggere gli eventuali dati presenti;
-se non ve ne sono (e la funzione restituisce pertanto un puntatore nullo) si
-ritorna immediatamente (\texttt{\small 16}) dato che questo significa che si è
-chiuso lo standard input e quindi concluso l'utilizzo del client; altrimenti
-(\texttt{\small 18--22}) si scrivono i dati appena letti sul socket,
-prevedendo una uscita immediata in caso di errore di scrittura.
-
-Controllato lo standard input si passa a controllare (\texttt{\small 25--40})
-il socket connesso, in caso di attività (\texttt{\small 26}) si esegue subito
-una \func{read} di cui si controlla il valore di ritorno; se questo è negativo
-(\texttt{\small 27--30}) si è avuto un errore e pertanto si esce
-immediatamente segnalandolo, se è nullo (\texttt{\small 31--34}) significa che
-il server ha chiuso la connessione, e di nuovo si esce con stampando prima un
-messaggio di avviso, altrimenti (\texttt{\small 35--39}) si effettua la
-terminazione della stringa e la si stampa a sullo standard output (uscendo in
-caso di errore), per ripetere il ciclo da capo.
+descriptor presenta attività in lettura, cominciando (\texttt{\small 14--24})
+con il file descriptor associato allo \textit{standard input}. In caso di
+attività (quando cioè \macro{FD\_ISSET} ritorna una valore diverso da zero) si
+esegue (\texttt{\small 15}) una \func{fgets} per leggere gli eventuali dati
+presenti; se non ve ne sono (e la funzione restituisce pertanto un puntatore
+nullo) si ritorna immediatamente (\texttt{\small 16}) dato che questo
+significa che si è chiuso lo \textit{standard input} e quindi concluso l'utilizzo del
+client; altrimenti (\texttt{\small 18--22}) si scrivono i dati appena letti
+sul socket, prevedendo una uscita immediata in caso di errore di scrittura.
+
+Controllato lo \textit{standard input} si passa a controllare (\texttt{\small
+ 25--40}) il socket connesso, in caso di attività (\texttt{\small 26}) si
+esegue subito una \func{read} di cui si controlla il valore di ritorno; se
+questo è negativo si è avuto un errore e pertanto si esce immediatamente
+segnalandolo (\texttt{\small 27--30}), se è nullo significa che il server ha
+chiuso la connessione, e di nuovo si esce con stampando prima un messaggio di
+avviso (\texttt{\small 31--34}), altrimenti (\texttt{\small 35--39}) si
+effettua la terminazione della stringa e la si stampa a sullo \textit{standard
+ output}, uscendo in caso di errore, per ripetere il ciclo da capo.
Con questo meccanismo il programma invece di essere bloccato in lettura sullo
-standard input resta bloccato sulla \func{select}, che ritorna soltanto quando
-viene rilevata attività su uno dei due file descriptor posti sotto controllo.
-Questo di norma avviene solo quando si è scritto qualcosa sullo standard
-input, o quando si riceve dal socket la risposta a quanto si era appena
-scritto. Ma adesso il client diventa capace di accorgersi immediatamente della
-terminazione del server; in tal caso infatti il server chiuderà il socket
-connesso, ed alla ricezione del FIN la funzione \func{select} ritornerà (come
+\textit{standard input} resta bloccato sulla \func{select}, che ritorna
+soltanto quando viene rilevata attività su uno dei due file descriptor posti
+sotto controllo. Questo di norma avviene solo quando si è scritto qualcosa
+sullo \textit{standard input}, o quando si riceve dal socket la risposta a quanto si
+era appena scritto.
+
+Ma adesso il client diventa capace di accorgersi immediatamente della
+terminazione del server; in tal caso infatti il server chiuderà il socket
+connesso, ed alla ricezione del FIN la funzione \func{select} ritornerà (come
illustrato in sez.~\ref{sec:TCP_sock_select}) segnalando una condizione di end
-of file, per cui il nostro client potrà uscire immediatamente.
+of file, per cui il nostro client potrà uscire immediatamente.
Riprendiamo la situazione affrontata in sez.~\ref{sec:TCP_server_crash},
terminando il server durante una connessione, in questo caso quello che
otterremo, una volta scritta una prima riga ed interrotto il server con un
-\texttt{C-c}, sarà:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.1
+\texttt{C-c}, sarà:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.1}
Prima riga
Prima riga
EOF sul socket
-\end{verbatim}%$
+\end{Console}
+%$
dove l'ultima riga compare immediatamente dopo aver interrotto il server. Il
-nostro client infatti è in grado di accorgersi immediatamente che il socket
-connesso è stato chiuso ed uscire immediatamente.
+nostro client infatti è in grado di accorgersi immediatamente che il socket
+connesso è stato chiuso ed uscire immediatamente.
Veniamo allora agli altri scenari di terminazione anomala visti in
-sez.~\ref{sec:TCP_conn_crash}. Il primo di questi è l'interruzione fisica della
+sez.~\ref{sec:TCP_conn_crash}. Il primo di questi è l'interruzione fisica della
connessione; in questo caso avremo un comportamento analogo al precedente, in
cui si scrive una riga e non si riceve risposta dal server e non succede
niente fino a quando non si riceve un errore di \errcode{EHOSTUNREACH} o
\errcode{ETIMEDOUT} a seconda dei casi.
-La differenza è che stavolta potremo scrivere più righe dopo l'interruzione,
-in quanto il nostro client dopo aver inviato i dati non si bloccherà più nella
-lettura dal socket, ma nella \func{select}; per questo potrà accettare
-ulteriore dati che scriverà di nuovo sul socket, fintanto che c'è spazio sul
-buffer di uscita (ecceduto il quale si bloccherà in scrittura). Si ricordi
-infatti che il client non ha modo di determinare se la connessione è attiva o
-meno (dato che in molte situazioni reali l'inattività può essere temporanea).
-Tra l'altro se si ricollega la rete prima della scadenza del timeout, potremo
-anche verificare come tutto quello che si era scritto viene poi effettivamente
-trasmesso non appena la connessione ridiventa attiva, per cui otterremo
-qualcosa del tipo:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.1
+La differenza è che stavolta potremo scrivere più righe dopo l'interruzione,
+in quanto il nostro client dopo aver inviato i dati non si bloccherà più nella
+lettura dal socket, ma nella \func{select}; per questo potrà accettare
+ulteriore dati che scriverà di nuovo sul socket, fintanto che c'è spazio sul
+buffer di uscita (ecceduto il quale si bloccherà in scrittura).
+
+Si ricordi infatti che il client non ha modo di determinare se la connessione
+è attiva o meno (dato che in molte situazioni reali l'inattività può essere
+temporanea). Tra l'altro se si ricollega la rete prima della scadenza del
+timeout, potremo anche verificare come tutto quello che si era scritto viene
+poi effettivamente trasmesso non appena la connessione ridiventa attiva, per
+cui otterremo qualcosa del tipo:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.1}
Prima riga
Prima riga
Seconda riga dopo l'interruzione
Seconda riga dopo l'interruzione
Terza riga
Quarta riga
-\end{verbatim}
+\end{Console}
+%$
in cui, una volta riconnessa la rete, tutto quello che abbiamo scritto durante
il periodo di disconnessione restituito indietro e stampato immediatamente.
Lo stesso comportamento visto in sez.~\ref{sec:TCP_server_crash} si riottiene
nel caso di un crollo completo della macchina su cui sta il server. In questo
-caso di nuovo il client non è in grado di accorgersi di niente dato che si
+caso di nuovo il client non è in grado di accorgersi di niente dato che si
suppone che il programma server non venga terminato correttamente, ma si
-blocchi tutto senza la possibilità di avere l'emissione di un segmento FIN che
-segnala la terminazione della connessione. Di nuovo fintanto che la
-connessione non si riattiva (con il riavvio della macchina del server) il
-client non è in grado di fare altro che accettare dell'input e tentare di
-inviarlo. La differenza in questo caso è che non appena la connessione
-ridiventa attiva i dati verranno sì trasmessi, ma essendo state perse tutte le
-informazioni relative alle precedenti connessioni ai tentativi di scrittura
-del client sarà risposto con un segmento RST che provocherà il ritorno di
-\func{select} per la ricezione di un errore di \errcode{ECONNRESET}.
+blocchi tutto senza la possibilità di avere l'emissione di un segmento FIN che
+segnala la terminazione della connessione.
+
+Di nuovo fintanto che la connessione non si riattiva (con il riavvio della
+macchina del server) il client non è in grado di fare altro che accettare
+dell'input e tentare di inviarlo. La differenza in questo caso è che non
+appena la connessione ridiventa attiva i dati verranno sì trasmessi, ma
+essendo state perse tutte le informazioni relative alle precedenti connessioni
+ai tentativi di scrittura del client sarà risposto con un segmento RST che
+provocherà il ritorno di \func{select} per la ricezione di un errore di
+\errcode{ECONNRESET}.
\subsection{La funzione \func{shutdown}}
\label{sec:TCP_shutdown}
-Come spiegato in sez.~\ref{sec:TCP_conn_term} il procedimento di chiusura di un
-socket TCP prevede che da entrambe le parti venga emesso un segmento FIN. È
+Come spiegato in sez.~\ref{sec:TCP_conn_term} il procedimento di chiusura di
+un socket TCP prevede che da entrambe le parti venga emesso un segmento FIN. È
pertanto del tutto normale dal punto di vista del protocollo che uno dei due
-capi chiuda la connessione, quando l'altro capo la lascia
-aperta.\footnote{abbiamo incontrato questa situazione nei vari scenari critici
- di sez.~\ref{sec:TCP_echo_critical}.}
-
-È pertanto possibile avere una situazione in cui un capo della connessione non
-avendo più nulla da scrivere, possa chiudere il socket, segnalando così
-l'avvenuta terminazione della trasmissione (l'altro capo riceverà infatti un
-end-of-file in lettura) mentre dall'altra parte si potrà proseguire la
-trasmissione dei dati scrivendo sul socket che da quel lato è ancora aperto.
-Questa è quella situazione in cui si dice che il socket è \textit{half
- closed}.
-
-Il problema che si pone è che se la chiusura del socket è effettuata con la
-funzione \func{close}, come spiegato in sez.~\ref{sec:TCP_func_close}, si perde
-ogni possibilità di poter rileggere quanto l'altro capo può continuare a
-scrivere. Per poter permettere allora di segnalare che si è concluso con la
-scrittura, continuando al contempo a leggere quanto può provenire dall'altro
-capo del socket si può allora usare la funzione \funcd{shutdown}, il cui
-prototipo è:
-\begin{prototype}{sys/socket.h}
-{int shutdown(int sockfd, int how)}
-
-Chiude un lato della 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:
+capi chiuda la connessione quando l'altro capo la lascia aperta; abbiamo
+incontrato questa situazione nei vari scenari critici di
+sez.~\ref{sec:TCP_echo_critical}.
+
+\itindbeg{half-close}
+
+È pertanto possibile avere una situazione in cui un capo della connessione,
+non avendo più nulla da scrivere, possa chiudere il socket, segnalando così
+l'avvenuta terminazione della trasmissione (l'altro capo riceverà infatti un
+\textit{end-of-file} in lettura) mentre dall'altra parte si potrà proseguire
+la trasmissione dei dati scrivendo sul socket che da quel lato è ancora
+aperto. Questa è quella situazione in cui si dice che il socket è
+\textsl{mezzo chiuso} (``\textit{half closed}'').
+
+Il problema che si pone è che se la chiusura del socket è effettuata con la
+funzione \func{close}, come spiegato in sez.~\ref{sec:TCP_func_close}, si
+perde ogni possibilità di poter leggere quanto l'altro capo può star
+continuando a scrivere. Per permettere di segnalare che si è finito con la
+scrittura, continuando al contempo a leggere quanto può provenire dall'altro
+capo del socket, si può usare la funzione \funcd{shutdown}, il cui prototipo
+è:
+
+\begin{funcproto}{
+\fhead{sys/socket.h}
+\fdecl{int shutdown(int sockfd, int how)}
+\fdesc{Chiude un lato della connessione fra due socket.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà uno dei valori:
\begin{errlist}
+ \item[\errcode{EBADF}] \param{sockfd} non è un file descriptor valido.
+ \item[\errcode{EINVAL}] il valore di \param{how} non è valido.
+ \item[\errcode{ENOTCONN}] il socket non è connesso.
\item[\errcode{ENOTSOCK}] il file descriptor non corrisponde a un socket.
- \item[\errcode{ENOTCONN}] il socket non è connesso.
- \end{errlist}
- ed inoltre \errval{EBADF}.}
-\end{prototype}
+ \end{errlist}}
+\end{funcproto}
La funzione prende come primo argomento il socket \param{sockfd} su cui si
vuole operare e come secondo argomento un valore intero \param{how} che indica
-la modalità di chiusura del socket, quest'ultima può prendere soltanto tre
+la modalità di chiusura del socket, quest'ultima può prendere soltanto tre
valori:
\begin{basedescript}{\desclabelwidth{2.2cm}\desclabelstyle{\nextlinelabel}}
-\item[\macro{SHUT\_RD}] chiude il lato in lettura del socket, non sarà più
+\item[\constd{SHUT\_RD}] chiude il lato in lettura del socket, non sarà più
possibile leggere dati da esso, tutti gli eventuali dati trasmessi
dall'altro capo del socket saranno automaticamente scartati dal kernel, che,
- in caso di socket TCP, provvederà comunque ad inviare i relativi segmenti di
+ in caso di socket TCP, provvederà comunque ad inviare i relativi segmenti di
ACK.
-\item[\macro{SHUT\_WR}] chiude il lato in scrittura del socket, non sarà più
+\item[\constd{SHUT\_WR}] chiude il lato in scrittura del socket, non sarà più
possibile scrivere dati su di esso. Nel caso di socket TCP la chiamata causa
l'emissione di un segmento FIN, secondo la procedura chiamata
\textit{half-close}. Tutti i dati presenti nel buffer di scrittura prima
della chiamata saranno inviati, seguiti dalla sequenza di chiusura
illustrata in sez.~\ref{sec:TCP_conn_term}.
-\item[\macro{SHUT\_RDWR}] chiude sia il lato in lettura che quello in
- scrittura del socket. È equivalente alla chiamata in sequenza con
- \macro{SHUT\_RD} e \macro{SHUT\_WR}.
+\item[\constd{SHUT\_RDWR}] chiude sia il lato in lettura che quello in
+ scrittura del socket. È equivalente alla chiamata in sequenza con
+ \const{SHUT\_RD} e \const{SHUT\_WR}.
\end{basedescript}
-Ci si può chiedere quale sia l'utilità di avere introdotto \macro{SHUT\_RDWR}
-quando questa sembra rendere \funcd{shutdown} del tutto equivalente ad una
-\func{close}. In realtà non è così, esiste infatti un'altra differenza con
-\func{close}, più sottile. Finora infatti non ci siamo presi la briga di
-sottolineare in maniera esplicita che, come per i file e le fifo, anche per i
-socket possono esserci più riferimenti contemporanei ad uno stesso socket. Per
-cui si avrebbe potuto avere l'impressione che sia una corrispondenza univoca
-fra un socket ed il file descriptor con cui vi si accede. Questo non è
-assolutamente vero, (e lo abbiamo già visto nel codice del server di
-fig.~\ref{fig:TCP_echo_server_first_code}), ed è invece assolutamente normale
-che, come per gli altri oggetti, ci possano essere più file descriptor che
+\itindend{half-close}
+
+Ci si può chiedere quale sia l'utilità di avere introdotto \const{SHUT\_RDWR}
+quando questa sembra rendere \func{shutdown} del tutto equivalente ad una
+\func{close}. In realtà non è così, esiste infatti un'altra differenza con
+\func{close}, più sottile. Finora infatti non ci siamo presi la briga di
+sottolineare in maniera esplicita che, come per i file e le \textit{fifo},
+anche per i socket possono esserci più riferimenti contemporanei ad uno stesso
+socket.
+
+Per cui si avrebbe potuto avere l'impressione che sia una corrispondenza
+univoca fra un socket ed il file descriptor con cui vi si accede. Questo non è
+assolutamente vero, (e lo abbiamo già visto nel codice del server di
+fig.~\ref{fig:TCP_echo_server_first_code}), ed è invece assolutamente normale
+che, come per gli altri oggetti, ci possano essere più file descriptor che
fanno riferimento allo stesso socket.
-Allora se avviene uno di questi casi quello che succederà è che la chiamata a
-\func{close} darà effettivamente avvio alla sequenza di chiusura di un socket
-soltanto quando il numero di riferimenti a quest'ultimo diventerà nullo.
+Allora se avviene uno di questi casi quello che succederà è che la chiamata a
+\func{close} darà effettivamente avvio alla sequenza di chiusura di un socket
+soltanto quando il numero di riferimenti a quest'ultimo diventerà nullo.
Fintanto che ci sono file descriptor che fanno riferimento ad un socket l'uso
-di \func{close} si limiterà a deallocare nel processo corrente il file
-descriptor utilizzato, ma il socket resterà pienamente accessibile attraverso
-tutti gli altri riferimenti. Se torniamo all'esempio originale del server di
+di \func{close} si limiterà a deallocare nel processo corrente il file
+descriptor utilizzato, ma il socket resterà pienamente accessibile attraverso
+tutti gli altri riferimenti.
+
+Se torniamo all'esempio originale del server di
fig.~\ref{fig:TCP_echo_server_first_code} abbiamo infatti che ci sono due
\func{close}, una sul socket connesso nel padre, ed una sul socket in ascolto
nel figlio, ma queste non effettuano nessuna chiusura reale di detti socket,
ed uno a quello in ascolto nel padre.
Questo non avviene affatto se si usa \func{shutdown} con argomento
-\macro{SHUT\_RDWR} al posto di \func{close}; in questo caso infatti la
+\const{SHUT\_RDWR} al posto di \func{close}; in questo caso infatti la
chiusura del socket viene effettuata immediatamente, indipendentemente dalla
-presenza di altri riferimenti attivi, e pertanto sarà efficace anche per tutti
+presenza di altri riferimenti attivi, e pertanto sarà efficace anche per tutti
gli altri file descriptor con cui, nello stesso o in altri processi, si fa
riferimento allo stesso socket.
-Il caso più comune di uso di \func{shutdown} è comunque quello della chiusura
-del lato in scrittura, per segnalare all'altro capo della connessione che si è
+Il caso più comune di uso di \func{shutdown} è comunque quello della chiusura
+del lato in scrittura, per segnalare all'altro capo della connessione che si è
concluso l'invio dei dati, restando comunque in grado di ricevere quanto
-questi potrà ancora inviarci. Questo è ad esempio l'uso che ci serve per
-rendere finalmente completo il nostro esempio sul servizio \textit{echo}. Il
-nostro client infatti presenta ancora un problema, che nell'uso che finora ne
-abbiamo fatto non è emerso, ma che ci aspetta dietro l'angolo non appena
-usciamo dall'uso interattivo e proviamo ad eseguirlo redirigendo standard
-input e standard output. Così se eseguiamo:
-\begin{verbatim}
-[piccardi@gont sources]$ ./echo 192.168.1.1 < ../fileadv.tex > copia
-\end{verbatim}%$
+questi potrà ancora inviarci. Questo è ad esempio l'uso che ci serve per
+rendere finalmente completo il nostro esempio sul servizio \textit{echo}.
+
+Il nostro client infatti presenta ancora un problema, che nell'uso che finora
+ne abbiamo fatto non è emerso, ma che ci aspetta dietro l'angolo non appena
+usciamo dall'uso interattivo e proviamo ad eseguirlo redirigendo
+\textit{standard input} e \textit{standard output}. Così se eseguiamo:
+\begin{Console}
+[piccardi@gont sources]$ \textbf{./echo 192.168.1.1 < ../fileadv.tex > copia}
+\end{Console}
+%$
vedremo che il file \texttt{copia} risulta mancare della parte finale.
Per capire cosa avviene in questo caso occorre tenere presente come avviene la
-comunicazione via rete; quando redirigiamo lo standard input il nostro client
-inizierà a leggere il contenuto del file \texttt{../fileadv.tex} a blocchi di
-dimensione massima pari a \texttt{MAXLINE} per poi scriverlo, alla massima
-velocità consentitagli dalla rete, sul socket. Dato che la connessione è con
-una macchina remota occorre un certo tempo perché i pacchetti vi arrivino,
-vengano processati, e poi tornino indietro. Considerando trascurabile il tempo
-di processo, questo tempo è quello impiegato nella trasmissione via rete, che
-viene detto RTT (dalla denominazione inglese \textit{Round Trip Time}) ed è
-quello che viene stimato con l'uso del comando \cmd{ping}.
+comunicazione via rete; quando redirigiamo lo \textit{standard input} il
+nostro client inizierà a leggere il contenuto del file \texttt{../fileadv.tex}
+a blocchi di dimensione massima pari a \texttt{MAXLINE} per poi scriverlo,
+alla massima velocità consentitagli dalla rete, sul socket. Dato che la
+connessione è con una macchina remota, occorre un certo tempo perché i
+pacchetti vi arrivino, vengano processati, e poi tornino
+indietro. Considerando trascurabile il tempo di processo, questo tempo è
+quello impiegato nella trasmissione via rete, che viene detto RTT (dalla
+denominazione inglese \itindex{Round~Trip~Time~(RTT)} \textit{Round Trip
+ Time}) ed è quello che viene stimato con l'uso del comando \cmd{ping}.
A questo punto, se torniamo al codice mostrato in
fig.~\ref{fig:TCP_ClientEcho_third}, possiamo vedere che mentre i pacchetti
sono in transito sulla rete il client continua a leggere e a scrivere fintanto
-che il file in ingresso finisce. Però non appena viene ricevuto un end-of-file
-in ingresso il nostro client termina. Nel caso interattivo, in cui si
-inviavano brevi stringhe una alla volta, c'era sempre il tempo di eseguire la
-lettura completa di quanto il server rimandava indietro. In questo caso
-invece, quando il client termina, essendo la comunicazione saturata e a piena
-velocità, ci saranno ancora pacchetti in transito sulla rete che devono
-arrivare al server e poi tornare indietro, ma siccome il client esce
-immediatamente dopo la fine del file in ingresso, questi non faranno a tempo a
-completare il percorso e verranno persi.
+che il file in ingresso finisce. Però non appena viene ricevuto un
+\textit{end-of-file} in ingresso il nostro client termina. Nel caso
+interattivo, in cui si inviavano brevi stringhe una alla volta, c'era sempre
+il tempo di eseguire la lettura completa di quanto il server rimandava
+indietro. In questo caso invece, quando il client termina, essendo la
+comunicazione saturata e a piena velocità, ci saranno ancora pacchetti in
+transito sulla rete che devono arrivare al server e poi tornare indietro, ma
+siccome il client esce immediatamente dopo la fine del file in ingresso,
+questi non faranno a tempo a completare il percorso e verranno persi.
Per evitare questo tipo di problema, invece di uscire una volta completata la
lettura del file in ingresso, occorre usare \func{shutdown} per effettuare la
-chiusura del lato in scrittura del socket. In questo modo il client segnalerà
-al server la chiusura del flusso dei dati, ma potrà continuare a leggere
+chiusura del lato in scrittura del socket. In questo modo il client segnalerà
+al server la chiusura del flusso dei dati, ma potrà continuare a leggere
quanto il server gli sta ancora inviando indietro, fino a quando anch'esso,
riconosciuta la chiusura del socket in scrittura da parte del client,
-effettuerà la chiusura dalla sua parte. Solo alla ricezione della chiusura del
-socket da parte del server il client potrà essere sicuro della ricezione di
+effettuerà la chiusura dalla sua parte. Solo alla ricezione della chiusura del
+socket da parte del server il client potrà essere sicuro della ricezione di
tutti i dati e della terminazione effettiva della connessione.
-\begin{figure}[!htb]
+\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/ClientEcho.c}
\end{minipage}
\normalsize
\label{fig:TCP_ClientEcho}
\end{figure}
-Si è allora riportato in fig.~\ref{fig:TCP_ClientEcho} la versione finale
+Si è allora riportato in fig.~\ref{fig:TCP_ClientEcho} la versione finale
della nostra funzione \func{ClientEcho}, in grado di gestire correttamente
l'intero flusso di dati fra client e server. Il codice completo del client,
comprendente la gestione delle opzioni a riga di comando e le istruzioni per
la creazione della connessione, si trova nel file
\texttt{TCP\_echo\_fourth.c}, distribuito coi sorgenti allegati alla guida.
-La nuova versione è molto simile alla precedente di
-fig.~\ref{fig:TCP_ClientEcho_third}; la prima differenza è l'introduzione
+La nuova versione è molto simile alla precedente di
+fig.~\ref{fig:TCP_ClientEcho_third}; la prima differenza è l'introduzione
(\texttt{\small 7}) della variabile \var{eof}, inizializzata ad un valore
nullo, che serve a mantenere traccia dell'avvenuta conclusione della lettura
del file in ingresso.
-La seconda modifica (\texttt{\small 12--15}) è stata quella di rendere
-subordinato ad un valore nullo di \var{eof} l'impostazione del file descriptor
-set per l'osservazione dello standard input. Se infatti il valore di \var{eof}
-è non nullo significa che si è già raggiunta la fine del file in ingresso ed è
-pertanto inutile continuare a tenere sotto controllo lo standard input nella
-successiva (\texttt{\small 16}) chiamata a \func{select}.
+La seconda modifica (\texttt{\small 12--15}) è stata quella di rendere
+subordinata ad un valore nullo di \var{eof} l'impostazione del file descriptor
+set per l'osservazione dello \textit{standard input}. Se infatti il valore di
+\var{eof} è non nullo significa che si è già raggiunta la fine del file in
+ingresso ed è pertanto inutile continuare a tenere sotto controllo lo
+\textit{standard input} nella successiva (\texttt{\small 16}) chiamata a
+\func{select}.
Le maggiori modifiche rispetto alla precedente versione sono invece nella
gestione (\texttt{\small 18--22}) del caso in cui la lettura con \func{fgets}
prima (\texttt{\small 19}) si imposta opportunamente \var{eof} ad un valore
non nullo, dopo di che (\texttt{\small 20}) si effettua la chiusura del lato
in scrittura del socket con \func{shutdown}. Infine (\texttt{\small 21}) si
-usa la macro \macro{FD\_CLR} per togliere lo standard input dal file
-descriptor set.
+usa la macro \macro{FD\_CLR} per togliere lo \textit{standard input} dal
+\textit{file descriptor set}.
-In questo modo anche se la lettura del file in ingresso è conclusa, la
+In questo modo anche se la lettura del file in ingresso è conclusa, la
funzione non esce dal ciclo principale (\texttt{\small 11--50}), ma continua
ad eseguirlo ripetendo la chiamata a \func{select} per tenere sotto controllo
soltanto il socket connesso, dal quale possono arrivare altri dati, che
-saranno letti (\texttt{\small 31}), ed opportunamente trascritti
-(\texttt{\small 44--48}) sullo standard output.
+saranno letti (\texttt{\small 31}) ed opportunamente trascritti
+(\texttt{\small 44--48}) sullo \textit{standard output}.
Il ritorno della funzione, e la conseguente terminazione normale del client,
viene invece adesso gestito all'interno (\texttt{\small 30--49}) della lettura
dei dati dal socket; se infatti dalla lettura del socket si riceve una
-condizione di end-of-file, la si tratterà (\texttt{\small 36--43}) in maniera
-diversa a seconda del valore di \var{eof}. Se infatti questa è diversa da zero
-(\texttt{\small 37--39}), essendo stata completata la lettura del file in
-ingresso, vorrà dire che anche il server ha concluso la trasmissione dei dati
-restanti, e si potrà uscire senza errori, altrimenti si stamperà
+condizione di \textit{end-of-file}, la si tratterà (\texttt{\small 36--43}) in
+maniera diversa a seconda del valore di \var{eof}. Se infatti questa è diversa
+da zero (\texttt{\small 37--39}), essendo stata completata la lettura del file
+in ingresso, vorrà dire che anche il server ha concluso la trasmissione dei
+dati restanti, e si potrà uscire senza errori, altrimenti si stamperà
(\texttt{\small 40--42}) un messaggio di errore per la chiusura precoce della
connessione.
-\subsection{Un server basato sull'I/O multiplexing}
+\subsection{Un server basato sull'\textit{I/O multiplexing}}
\label{sec:TCP_serv_select}
Seguendo di nuovo le orme di Stevens in \cite{UNP1} vediamo ora come con
-l'utilizzo dell'I/O multiplexing diventi possibile riscrivere completamente il
-nostro server \textit{echo} con una architettura completamente diversa, in
-modo da evitare di dover creare un nuovo processo tutte le volte che si ha una
-connessione.\footnote{ne faremo comunque una implementazione diversa rispetto
- a quella presentata da Stevens in \cite{UNP1}.}
-
-La struttura del nuovo server è illustrata in
+l'utilizzo dell'\textit{I/O multiplexing} diventi possibile riscrivere
+completamente il nostro server \textit{echo} con una architettura
+completamente diversa, in modo da evitare di dover creare un nuovo processo
+tutte le volte che si ha una connessione.\footnote{ne faremo comunque una
+ realizzazione diversa rispetto a quella presentata da Stevens in
+ \cite{UNP1}.}
+
+La struttura del nuovo server è illustrata in
fig.~\ref{fig:TCP_echo_multiplex}, in questo caso avremo un solo processo che
ad ogni nuova connessione da parte di un client sul socket in ascolto si
-limiterà a registrare l'entrata in uso di un nuovo file descriptor ed
-utilizzerà \func{select} per rilevare la presenza di dati in arrivo su tutti i
+limiterà a registrare l'entrata in uso di un nuovo file descriptor ed
+utilizzerà \func{select} per rilevare la presenza di dati in arrivo su tutti i
file descriptor attivi, operando direttamente su ciascuno di essi.
-\begin{figure}[htb]
- \centering
- \includegraphics[width=13cm]{img/TCPechoMult}
- \caption{Schema del nuovo server echo basato sull'I/O multiplexing.}
+\begin{figure}[!htb]
+ \centering \includegraphics[width=13cm]{img/TCPechoMult}
+ \caption{Schema del nuovo server echo basato sull'\textit{I/O multiplexing}.}
\label{fig:TCP_echo_multiplex}
\end{figure}
-La sezione principale del codice del nuovo server è illustrata in
-fig.~\ref{fig:TCP_SelectEchod}. Si è tralasciata al solito la gestione delle
-opzioni, che è identica alla versione precedente. Resta invariata anche tutta
+La sezione principale del codice del nuovo server è illustrata in
+fig.~\ref{fig:TCP_SelectEchod}. Si è tralasciata al solito la gestione delle
+opzioni, che è identica alla versione precedente. Resta invariata anche tutta
la parte relativa alla gestione dei segnali, degli errori, e della cessione
-dei privilegi, così come è identica la gestione della creazione del socket (si
-può fare riferimento al codice già illustrato in
-sez.~\ref{sec:TCPsimp_server_main}); al solito il codice completo del server è
+dei privilegi, così come è identica la gestione della creazione del socket (si
+può fare riferimento al codice già illustrato in
+sez.~\ref{sec:TCPsimp_server_main}); al solito il codice completo del server è
disponibile coi sorgenti allegati nel file \texttt{select\_echod.c}.
\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/select_echod.c}
\end{minipage}
\normalsize
- \caption{La sezione principale del codice della nuova versione di server
- \textit{echo} basati sull'uso della funzione \func{select}.}
+ \caption{La sezione principale della nuova versione di server
+ \textit{echo} basato sull'uso della funzione \func{select}.}
\label{fig:TCP_SelectEchod}
\end{figure}
In questo caso, una volta aperto e messo in ascolto il socket, tutto quello
-che ci servirà sarà chiamare \func{select} per rilevare la presenza di nuove
-connessioni o di dati in arrivo, e processarli immediatamente. Per
-implementare lo schema mostrato in fig.~\ref{fig:TCP_echo_multiplex}, il
-programma usa una tabella dei socket connessi mantenuta nel vettore
-\var{fd\_open} dimensionato al valore di \const{FD\_SETSIZE}, ed una variabile
-\var{max\_fd} per registrare il valore più alto dei file descriptor aperti.
-
-Prima di entrare nel ciclo principale (\texttt{\small 6--56}) la nostra
+che ci servirà sarà chiamare \func{select} per rilevare la presenza di nuove
+connessioni o di dati in arrivo, e processarli immediatamente. Per realizzare
+lo schema mostrato in fig.~\ref{fig:TCP_echo_multiplex} il programma usa una
+tabella dei socket connessi mantenuta nel vettore \var{fd\_open} dimensionato
+al valore di \const{FD\_SETSIZE}, ed una variabile \var{max\_fd} per
+registrare il valore più alto dei file descriptor aperti.
+
+Prima di entrare nel ciclo principale (\texttt{\small 5--53}) la nostra
tabella viene inizializzata (\texttt{\small 2}) a zero (valore che
-utilizzeremo come indicazione del fatto che il relativo file descriptor non è
+utilizzeremo come indicazione del fatto che il relativo file descriptor non è
aperto), mentre il valore massimo (\texttt{\small 3}) per i file descriptor
-aperti viene impostato a quello del socket in ascolto,\footnote{in quanto esso
- è l'unico file aperto, oltre i tre standard, e pertanto avrà il valore più
- alto.} che verrà anche (\texttt{\small 4}) inserito nella tabella.
+aperti viene impostato a quello del socket in ascolto, in quanto esso è
+l'unico file aperto, oltre i tre standard, e pertanto avrà il valore più alto,
+che verrà anche (\texttt{\small 4}) inserito nella tabella.
-La prima sezione (\texttt{\small 7--10}) del ciclo principale esegue la
+La prima sezione (\texttt{\small 6--8}) del ciclo principale esegue la
costruzione del \textit{file descriptor set} \var{fset} in base ai socket
-connessi in un certo momento; all'inizio ci sarà soltanto il socket in
-ascolto, ma nel prosieguo delle operazioni, verranno utilizzati anche tutti i
-socket connessi registrati nella tabella \var{fd\_open}. Dato che la chiamata
-di \func{select} modifica il valore del \textit{file descriptor set}, è
-necessario ripetere (\texttt{\small 7}) ogni volta il suo azzeramento, per poi
-procedere con il ciclo (\texttt{\small 8--10}) in cui si impostano i socket
-trovati attivi.
+connessi in un certo momento; all'inizio ci sarà soltanto il socket in ascolto
+ma nel prosieguo delle operazioni verranno utilizzati anche tutti i socket
+connessi registrati nella tabella \var{fd\_open}. Dato che la chiamata di
+\func{select} modifica il valore del \textit{file descriptor set} è necessario
+ripetere (\texttt{\small 6}) ogni volta il suo azzeramento per poi procedere
+con il ciclo (\texttt{\small 7--8}) in cui si impostano i socket trovati
+attivi.
Per far questo si usa la caratteristica dei file descriptor, descritta in
-sez.~\ref{sec:file_open}, per cui il kernel associa sempre ad ogni nuovo file
-il file descriptor con il valore più basso disponibile. Questo fa sì che si
-possa eseguire il ciclo (\texttt{\small 8}) a partire da un valore minimo, che
-sarà sempre quello del socket in ascolto, mantenuto in \var{list\_fd}, fino al
-valore massimo di \var{max\_fd} che dovremo aver cura di tenere aggiornato.
-Dopo di che basterà controllare (\texttt{\small 9}) nella nostra tabella se il
-file descriptor è in uso o meno,\footnote{si tenga presente che benché il
- kernel assegni sempre il primo valore libero, dato che nelle operazioni i
+sez.~\ref{sec:file_open_close}, per cui il kernel associa sempre ad ogni nuovo
+file il file descriptor con il valore più basso disponibile. Questo fa sì che
+si possa eseguire il ciclo (\texttt{\small 7}) a partire da un valore minimo,
+che sarà sempre quello del socket in ascolto, mantenuto in \var{list\_fd},
+fino al valore massimo di \var{max\_fd} che dovremo aver cura di tenere
+aggiornato. Dopo di che basterà controllare (\texttt{\small 8}) nella nostra
+tabella se il file descriptor è in uso o meno,\footnote{si tenga presente che
+ benché il kernel assegni sempre il primo valore libero, si potranno sempre
+ avere dei \textsl{buchi} nella nostra tabella dato che nelle operazioni i
socket saranno aperti e chiusi in corrispondenza della creazione e
- conclusione delle connessioni, si potranno sempre avere dei \textsl{buchi}
- nella nostra tabella.} e impostare \var{fset} di conseguenza.
+ conclusione delle connessioni.} e impostare \var{fset} di conseguenza.
Una volta inizializzato con i socket aperti il nostro \textit{file descriptor
set} potremo chiamare \func{select} per fargli osservare lo stato degli
stessi (in lettura, presumendo che la scrittura sia sempre consentita). Come
per il precedente esempio di sez.~\ref{sec:TCP_child_hand}, essendo questa
-l'unica funzione che può bloccarsi, ed essere interrotta da un segnale, la
-eseguiremo (\texttt{\small 11--12}) all'interno di un ciclo di \code{while}
+l'unica funzione che può bloccarsi ed essere interrotta da un segnale, la
+eseguiremo (\texttt{\small 9--10}) all'interno di un ciclo di \code{while},
che la ripete indefinitamente qualora esca con un errore di \errcode{EINTR}.
-Nel caso invece di un errore normale si provvede (\texttt{\small 13--16}) ad
-uscire stampando un messaggio di errore.
-
-Se invece la funzione ritorna normalmente avremo in \var{n} il numero di
-socket da controllare. Nello specifico si danno due possibili casi diversi per
-cui \func{select} può essere ritornata: o si è ricevuta una nuova connessione
-ed è pronto il socket in ascolto, sul quale si può eseguire \func{accept} o
-c'è attività su uno dei socket connessi, sui quali si può eseguire
-\func{read}.
-
-Il primo caso viene trattato immediatamente (\texttt{\small 17--26}): si
-controlla (\texttt{\small 17}) che il socket in ascolto sia fra quelli attivi,
-nel qual caso anzitutto (\texttt{\small 18}) se ne decrementa il numero in
-\var{n}; poi, inizializzata (\texttt{\small 19}) la lunghezza della struttura
-degli indirizzi, si esegue \func{accept} per ottenere il nuovo socket connesso
-controllando che non ci siano errori (\texttt{\small 20--23}). In questo caso
-non c'è più la necessità di controllare per interruzioni dovute a segnali, in
-quanto siamo sicuri che \func{accept} non si bloccherà. Per completare la
-trattazione occorre a questo punto aggiungere (\texttt{\small 24}) il nuovo
-file descriptor alla tabella di quelli connessi, ed inoltre, se è il caso,
-aggiornare (\texttt{\small 25}) il valore massimo in \var{max\_fd}.
+Nel caso invece di un errore normale si provvede (\texttt{\small 11--14}) ad
+uscire dal programma stampando un messaggio di errore.
+
+Infine quando la funzione ritorna normalmente avremo in \var{n} il numero di
+socket da controllare. Nello specifico si danno due casi per cui \func{select}
+può ritornare: o si è ricevuta una nuova connessione ed è pronto il socket in
+ascolto, sul quale si può eseguire \func{accept}, o c'è attività su uno dei
+socket connessi, sui quali si può eseguire \func{read}.
+
+Il primo caso viene trattato immediatamente (\texttt{\small 15--24}): si
+controlla (\texttt{\small 15}) che il socket in ascolto sia fra quelli attivi,
+nel qual caso anzitutto (\texttt{\small 16}) se ne decrementa il numero
+mantenuto nella variabile \var{n}. Poi, inizializzata (\texttt{\small 17}) la
+lunghezza della struttura degli indirizzi, si esegue \func{accept} per
+ottenere il nuovo socket connesso, controllando che non ci siano errori
+(\texttt{\small 18--21}). In questo caso non c'è più la necessità di
+controllare per interruzioni dovute a segnali, in quanto siamo sicuri che
+\func{accept} non si bloccherà. Per completare la trattazione occorre a questo
+punto aggiungere (\texttt{\small 22}) il nuovo file descriptor alla tabella di
+quelli connessi, ed inoltre, se è il caso, aggiornare (\texttt{\small 23}) il
+valore massimo in \var{max\_fd}.
Una volta controllato l'arrivo di nuove connessioni si passa a verificare se
-vi sono dati sui socket connessi, per questo si ripete un ciclo
-(\texttt{\small 29--55}) fintanto che il numero di socket attivi \var{n} resta
-diverso da zero; in questo modo se l'unico socket con attività era quello
-connesso, avendo opportunamente decrementato il contatore, il ciclo verrà
-saltato, e si ritornerà immediatamente (ripetuta l'inizializzazione del file
-descriptor set con i nuovi valori nella tabella) alla chiamata di
-\func{accept}. Se il socket attivo non è quello in ascolto, o ce ne sono
-comunque anche altri, il valore di \var{n} non sarà nullo ed il controllo sarà
-eseguito. Prima di entrare nel ciclo comunque si inizializza (\texttt{\small
- 28}) il valore della variabile \var{i} che useremo come indice nella tabella
-\var{fd\_open} al valore minimo, corrispondente al file descriptor del socket
-in ascolto.
-
-Il primo passo (\texttt{\small 30}) nella verifica è incrementare il valore
+ci sono dati sui socket connessi, per questo si ripete un ciclo
+(\texttt{\small 26--52}) fintanto che il numero di socket attivi indicato
+dalla variabile \var{n} resta diverso da zero. In questo modo, se l'unico
+socket con attività era quello connesso, avendola opportunamente decrementata
+in precedenza, essa risulterà nulla, pertanto il ciclo di verifica verrà
+saltato e si ritornerà all'inzizio del ciclo principale, ripetendo, dopo
+l'inizializzazione del \textit{file descriptor set} con i nuovi valori nella
+tabella, la chiamata di \func{select}.
+
+Se il socket attivo non è quello in ascolto, o ce ne sono comunque anche
+altri, il valore di \var{n} non sarà nullo ed il controllo sarà
+eseguito. Prima di entrare nel ciclo di veridica comunque si inizializza
+(\texttt{\small 25}) il valore della variabile \var{i}, che useremo come
+indice nella tabella \var{fd\_open}, al valore minimo, corrispondente al file
+descriptor del socket in ascolto.
+
+Il primo passo (\texttt{\small 27}) nella verifica è incrementare il valore
dell'indice \var{i} per posizionarsi sul primo valore possibile per un file
descriptor associato ad un eventuale socket connesso, dopo di che si controlla
-(\texttt{\small 31}) se questo è nella tabella dei socket connessi, chiedendo
+(\texttt{\small 28}) se questo è nella tabella dei socket connessi, chiedendo
la ripetizione del ciclo in caso contrario. Altrimenti si passa a verificare
-(\texttt{\small 32}) se il file descriptor corrisponde ad uno di quelli
-attivi, e nel caso si esegue (\texttt{\small 33}) una lettura, uscendo con un
-messaggio in caso di errore (\texttt{\small 34--38}).
-
-Se (\texttt{\small 39}) il numero di byte letti \var{nread} è nullo si è in
-presenza del caso di un \textit{end-of-file}, indice che una connessione che
-si è chiusa, che deve essere trattato (\texttt{\small 39--48}) opportunamente.
-Il primo passo è chiudere (\texttt{\small 40}) anche il proprio capo del
-socket e rimuovere (\texttt{\small 41}) il file descriptor dalla tabella di
-quelli aperti, inoltre occorre verificare (\texttt{\small 42}) se il file
-descriptor chiuso è quello con il valore più alto, nel qual caso occorre
-trovare (\texttt{\small 42--46}) il nuovo massimo, altrimenti (\texttt{\small
- 47}) si può ripetere il ciclo da capo per esaminare (se ne restano)
-ulteriori file descriptor attivi.
-
-Se però è stato chiuso il file descriptor più alto, dato che la scansione dei
-file descriptor attivi viene fatta a partire dal valore più basso, questo
+(\texttt{\small 29}) se il file descriptor corrisponde ad uno di quelli
+attivi, e nel caso si esegue (\texttt{\small 30}) una lettura, uscendo con un
+messaggio in caso di errore (\texttt{\small 31--35}).
+
+Se (\texttt{\small 36}) il numero di byte letti \var{nread} è nullo si è in
+presenza di una \textit{end-of-file}, indice che una connessione che si è
+chiusa, che deve essere trattata (\texttt{\small 36--45}) opportunamente. Il
+primo passo è chiudere (\texttt{\small 37}) anche il proprio capo del socket e
+rimuovere (\texttt{\small 38}) il file descriptor dalla tabella di quelli
+aperti, inoltre occorre verificare (\texttt{\small 39}) se il file descriptor
+chiuso è quello con il valore più alto, nel qual caso occorre trovare
+(\texttt{\small 39--43}) il nuovo massimo, altrimenti (\texttt{\small 44}) si
+può ripetere il ciclo da capo per esaminare (se ne restano) ulteriori file
+descriptor attivi.
+
+Se però è stato chiuso il file descriptor più alto, dato che la scansione dei
+file descriptor attivi viene fatta a partire dal valore più basso, questo
significa che siamo anche arrivati alla fine della scansione, per questo
possiamo utilizzare direttamente il valore dell'indice \var{i} con un ciclo
-all'indietro (\texttt{\small 43}) che trova il primo valore per cui la tabella
-presenta un file descriptor aperto, e lo imposta (\texttt{\small 44}) come
-nuovo massimo, per poi tornare (\texttt{\small 44}) al ciclo principale con un
+all'indietro (\texttt{\small 40}) che trova il primo valore per cui la tabella
+presenta un file descriptor aperto, e lo imposta (\texttt{\small 41}) come
+nuovo massimo, per poi tornare (\texttt{\small 42}) al ciclo principale con un
\code{break}, e rieseguire \func{select}.
Se infine si sono effettivamente letti dei dati dal socket (ultimo caso
-rimasto) si potrà invocare immediatamente (\texttt{\small 49})
+rimasto) si potrà invocare immediatamente (\texttt{\small 46})
\func{FullWrite} per riscriverli indietro sul socket stesso, avendo cura di
-uscire con un messaggio in caso di errore (\texttt{\small 50--53}). Si noti
+uscire con un messaggio in caso di errore (\texttt{\small 47--50}). Si noti
che nel ciclo si esegue una sola lettura, contrariamente a quanto fatto con la
precedente versione (si riveda il codice di fig.~\ref{fig:TCP_ServEcho_second})
in cui si continuava a leggere fintanto che non si riceveva un
-\textit{end-of-file}, questo perché usando l'\textit{I/O multiplexing} non si
-vuole essere bloccati in lettura. L'uso di \func{select} ci permette di
-trattare automaticamente anche il caso in cui la \func{read} non è stata in
-grado di leggere tutti i dati presenti sul socket, dato che alla iterazione
-successiva \func{select} ritornerà immediatamente segnalando l'ulteriore
-disponibilità.
-
-Il nostro server comunque soffre di una vulnerabilità per un attacco di tipo
-\textit{Denial of Service}. Il problema è che in caso di blocco di una
+\textit{end-of-file}, questo perché usando l'\textit{I/O multiplexing} non si
+vuole essere bloccati in lettura.
+
+L'uso di \func{select} ci permette di trattare automaticamente anche il caso
+in cui la \func{read} non è stata in grado di leggere tutti i dati presenti
+sul socket, dato che alla iterazione successiva \func{select} ritornerà
+immediatamente segnalando l'ulteriore disponibilità.
+
+Il nostro server comunque soffre di una vulnerabilità per un attacco di tipo
+\textit{Denial of Service}. Il problema è che in caso di blocco di una
qualunque delle funzioni di I/O, non avendo usato processi separati, tutto il
-server si ferma e non risponde più a nessuna richiesta. Abbiamo scongiurato
+server si ferma e non risponde più a nessuna richiesta. Abbiamo scongiurato
questa evenienza per l'I/O in ingresso con l'uso di \func{select}, ma non vale
-altrettanto per l'I/O in uscita. Il problema pertanto può sorgere qualora una
-delle chiamate a \func{write} effettuate da \func{FullWrite} si blocchi. Con
-il funzionamento normale questo non accade in quanto il server si limita a
+altrettanto per l'I/O in uscita. Il problema pertanto può sorgere qualora una
+delle chiamate a \func{write} effettuate da \func{FullWrite} si blocchi.
+
+Con il funzionamento normale questo non accade in quanto il server si limita a
scrivere quanto riceve in ingresso, ma qualora venga utilizzato un client
malevolo che esegua solo scritture e non legga mai indietro l'\textsl{eco} del
server, si potrebbe giungere alla saturazione del buffer di scrittura, ed al
Le possibili soluzioni in questo caso sono quelle di ritornare ad eseguire il
ciclo di risposta alle richieste all'interno di processi separati, utilizzare
un timeout per le operazioni di scrittura, o eseguire queste ultime in
-modalità non bloccante, concludendo le operazioni qualora non vadano a buon
+modalità non bloccante, concludendo le operazioni qualora non vadano a buon
fine.
-
-\subsection{I/O multiplexing con \func{poll}}
+\subsection{\textit{I/O multiplexing} con \func{poll}}
\label{sec:TCP_serv_poll}
-Finora abbiamo trattato le problematiche risolubili con l'I/O multiplexing
-impiegando la funzione \func{select}; questo è quello che avviene nella
-maggior parte dei casi, in quanto essa è nata sotto BSD proprio per affrontare
-queste problematiche con i socket. Abbiamo però visto in
+Finora abbiamo trattato le problematiche risolubili con l'\textit{I/O
+ multiplexing} impiegando la funzione \func{select}. Questo è quello che
+avviene nella maggior parte dei casi, in quanto essa è nata sotto BSD proprio
+per affrontare queste problematiche con i socket. Abbiamo però visto in
sez.~\ref{sec:file_multiplexing} come la funzione \func{poll} possa costituire
-una alternativa a \func{select}, con alcuni vantaggi.\footnote{non soffrendo
- delle limitazioni dovute all'uso dei \textit{file descriptor set}.}
+una alternativa a \func{select}, con alcuni vantaggi, non soffrendo delle
+limitazioni dovute all'uso dei \textit{file descriptor set}.
Ancora una volta in sez.~\ref{sec:file_poll} abbiamo trattato la funzione in
maniera generica, parlando di file descriptor, ma come per \func{select}
-quando si ha a che fare con dei socket il concetto di essere \textsl{pronti}
-per l'I/O deve essere specificato nei dettagli, per tener conto delle
+quando si ha a che fare con dei socket, il concetto di essere \textsl{pronti}
+per l'I/O deve essere specificato nei dettagli per tener conto delle
condizioni della rete. Inoltre deve essere specificato come viene classificato
il traffico nella suddivisione fra dati normali e prioritari. In generale
pertanto:
\item i dati inviati su un socket vengono considerati traffico normale,
pertanto vengono rilevati alla loro ricezione sull'altro capo da una
selezione effettuata con \const{POLLIN} o \const{POLLRDNORM};
-\item i dati \textit{out-of-band} su un socket TCP vengono considerati
+\item i dati urgenti \textit{out-of-band} (vedi
+ sez.~\ref{sec:TCP_urgent_data}) su un socket TCP vengono considerati
traffico prioritario e vengono rilevati da una condizione \const{POLLIN},
\const{POLLPRI} o \const{POLLRDBAND}.
-\item la chiusura di una connessione (cioè la ricezione di un segmento FIN)
+\item la chiusura di una connessione (cioè la ricezione di un segmento FIN)
viene considerato traffico normale, pertanto viene rilevato da una
condizione \const{POLLIN} o \const{POLLRDNORM}, ma una conseguente chiamata
- a \func{read} restituirà 0.
-\item la disponibilità di spazio sul socket per la scrittura di dati viene
+ a \func{read} restituirà 0.
+\item la disponibilità di spazio sul socket per la scrittura di dati viene
segnalata con una condizione \const{POLLOUT}.
\item quando uno dei due capi del socket chiude un suo lato della connessione
con \func{shutdown} si riceve una condizione di \const{POLLHUP}.
\item la presenza di un errore sul socket (sia dovuta ad un segmento RST che a
timeout) viene considerata traffico normale, ma viene segnalata anche dalla
condizione \const{POLLERR}.
-\item la presenza di una nuova connessione su un socket in ascolto può essere
- considerata sia traffico normale che prioritario, nel caso di Linux
- l'implementazione la classifica come normale.
+\item la presenza di una nuova connessione su un socket in ascolto può essere
+ considerata sia traffico normale che prioritario, nel caso di Linux la
+ realizzazione dello \textit{stack TCP} la classifica come normale.
\end{itemize}
-Come esempio dell'uso di \func{poll} proviamo allora a reimplementare il
-server \textit{echo} secondo lo schema di fig.~\ref{fig:TCP_echo_multiplex}
-usando \func{poll} al posto di \func{select}. In questo caso dovremo fare
-qualche modifica, per tenere conto della diversa sintassi delle due funzioni,
-ma la struttura del programma resta sostanzialmente la stessa.
+Come esempio dell'uso di \func{poll} proviamo allora a riscrivere il server
+\textit{echo} secondo lo schema di fig.~\ref{fig:TCP_echo_multiplex} usando
+\func{poll} al posto di \func{select}. In questo caso dovremo fare qualche
+modifica, per tenere conto della diversa sintassi delle due funzioni, ma la
+struttura del programma resta sostanzialmente la stessa.
\begin{figure}[!htbp]
\footnotesize \centering
- \begin{minipage}[c]{15.6cm}
+ \begin{minipage}[c]{\codesamplewidth}
\includecodesample{listati/poll_echod.c}
\end{minipage}
\normalsize
- \caption{La sezione principale del codice della nuova versione di server
- \textit{echo} basati sull'uso della funzione \func{poll}.}
+ \caption{La sezione principale della nuova versione di server
+ \textit{echo} basato sull'uso della funzione \func{poll}.}
\label{fig:TCP_PollEchod}
\end{figure}
-In fig.~\ref{fig:TCP_PollEchod} è riportata la sezione principale della nuova
-versione del server, la versione completa del codice è riportata nel file
+In fig.~\ref{fig:TCP_PollEchod} è riportata la sezione principale della nuova
+versione del server, la versione completa del codice è riportata nel file
\texttt{poll\_echod.c} dei sorgenti allegati alla guida. Al solito nella
figura si sono tralasciate la gestione delle opzioni, la creazione del socket
in ascolto, la cessione dei privilegi e le operazioni necessarie a far
programma.
Come per il precedente server basato su \func{select} il primo passo
-(\texttt{\small 2--8}) è quello di inizializzare le variabili necessarie. Dato
+(\texttt{\small 2--8}) è quello di inizializzare le variabili necessarie. Dato
che in questo caso dovremo usare un vettore di strutture occorre anzitutto
(\texttt{\small 2}) allocare la memoria necessaria utilizzando il numero
massimo \var{n} di socket osservabili, che viene impostato attraverso
l'opzione \texttt{-n} ed ha un valore di default di 256.
Dopo di che si preimposta (\texttt{\small 3}) il valore \var{max\_fd} del file
-descriptor aperto con valore più alto a quello del socket in ascolto (al
+descriptor aperto con valore più alto a quello del socket in ascolto (al
momento l'unico), e si provvede (\texttt{\small 4--7}) ad inizializzare le
-strutture, disabilitando (\texttt{\small 5}) l'osservazione con un valore
-negativo del campo \var{fd} ma predisponendo (\texttt{\small 6}) il campo
+strutture, disabilitando l'osservazione (\texttt{\small 5}) con un valore
+negativo del campo \var{fd}, ma predisponendo (\texttt{\small 6}) il campo
\var{events} per l'osservazione dei dati normali con \const{POLLRDNORM}.
Infine (\texttt{\small 8}) si attiva l'osservazione del socket in ascolto
inizializzando la corrispondente struttura. Questo metodo comporta, in
-modalità interattiva, lo spreco di tre strutture (quelle relative a standard
-input, output ed error) che non vengono mai utilizzate in quanto la prima è
-sempre quella relativa al socket in ascolto.
+modalità interattiva, lo spreco di tre strutture (quelle relative a
+\textit{standard input}, \textit{standard output} e \textit{standard error})
+che non vengono mai utilizzate in quanto la prima è sempre quella relativa al
+socket in ascolto.
Una volta completata l'inizializzazione tutto il lavoro viene svolto
-all'interno del ciclo principale \texttt{\small 10--55}) che ha una struttura
+all'interno del ciclo principale \texttt{\small 9--53}) che ha una struttura
sostanzialmente identica a quello usato per il precedente esempio basato su
-\func{select}. La prima istruzione (\texttt{\small 11--12}) è quella di
-eseguire \func{poll} all'interno di un ciclo che la ripete qualora venisse
-interrotta da un segnale, da cui si esce soltanto quando la funzione ritorna,
-restituendo nella variabile \var{n} il numero di file descriptor trovati
-attivi. Qualora invece si sia ottenuto un errore si procede (\texttt{\small
- 13--16}) alla terminazione immediata del processo provvedendo a stampare una
-descrizione dello stesso.
-
-Una volta ottenuta dell'attività su un file descriptor si hanno di nuovo due
-possibilità. La prima possibilità è che ci sia attività sul socket in ascolto,
-indice di una nuova connessione, nel qual caso si controlla (\texttt{\small
- 17}) se il campo \var{revents} della relativa struttura è attivo; se è così
-si provvede (\texttt{\small 18}) a decrementare la variabile \var{n} (che
-assume il significato di numero di file descriptor attivi rimasti da
-controllare) per poi (\texttt{\small 19--23}) effettuare la chiamata ad
-\func{accept}, terminando il processo in caso di errore. Se la chiamata ad
-\func{accept} ha successo si procede attivando (\texttt{\small 24}) la
-struttura relativa al nuovo file descriptor da essa ottenuto, modificando
-(\texttt{\small 24}) infine quando necessario il valore massimo dei file
-descriptor aperti mantenuto in \var{max\_fd}.
-
-La seconda possibilità è che vi sia dell'attività su uno dei socket aperti in
-precedenza, nel qual caso si inizializza (\texttt{\small 27}) l'indice \var{i}
+\func{select}. La prima istruzione (\texttt{\small 10}) è quella di eseguire
+\func{poll} all'interno di un ciclo che la ripete qualora venisse interrotta
+da un segnale, da cui si esce soltanto quando la funzione ritorna restituendo
+nella variabile \var{n} il numero di file descriptor trovati attivi. Qualora
+invece si sia ottenuto un errore si procede (\texttt{\small 11--14}) alla
+terminazione immediata del processo provvedendo a stampare una descrizione
+dello stesso.
+
+Una volta ottenuta dell'attività su un file descriptor si hanno di nuovo due
+possibilità. La prima è che ci sia attività sul socket in ascolto, indice di
+una nuova connessione, nel qual caso si controlla (\texttt{\small 17}) se il
+campo \var{revents} della relativa struttura è attivo; se è così si provvede
+(\texttt{\small 16}) a decrementare la variabile \var{n} (che assume il
+significato di numero di file descriptor attivi rimasti da controllare) per
+poi (\texttt{\small 17--21}) effettuare la chiamata ad \func{accept},
+terminando il processo in caso di errore. Se la chiamata ad \func{accept} ha
+successo si procede attivando (\texttt{\small 22}) la struttura relativa al
+nuovo file descriptor da essa ottenuto, modificando (\texttt{\small 23})
+infine quando necessario il valore massimo dei file descriptor aperti
+mantenuto in \var{max\_fd}.
+
+La seconda possibilità è che vi sia dell'attività su uno dei socket aperti in
+precedenza, nel qual caso si inizializza (\texttt{\small 25}) l'indice \var{i}
del vettore delle strutture \struct{pollfd} al valore del socket in ascolto,
dato che gli ulteriori socket aperti avranno comunque un valore superiore. Il
-ciclo (\texttt{\small 28--54}) prosegue fintanto che il numero di file
-descriptor attivi, mantenuto nella variabile \var{n}, è diverso da zero. Se
+ciclo (\texttt{\small 26--52}) prosegue fintanto che il numero di file
+descriptor attivi, mantenuto nella variabile \var{n}, è diverso da zero. Se
pertanto ci sono ancora socket attivi da individuare si comincia con
-l'incrementare (\texttt{\small 30}) l'indice e controllare (\texttt{\small
- 31}) se corrisponde ad un file descriptor in uso analizzando il valore del
+l'incrementare (\texttt{\small 27}) l'indice e controllare (\texttt{\small
+ 28}) se corrisponde ad un file descriptor in uso analizzando il valore del
campo \var{fd} della relativa struttura e chiudendo immediatamente il ciclo
-qualora non lo sia. Se invece il file descriptor è in uso si verifica
-(\texttt{\small 31}) se c'è stata attività controllando il campo
-\var{revents}.
-
-Di nuovo se non si verifica la presenza di attività il ciclo si chiude subito,
-altrimenti si provvederà (\texttt{\small 32}) a decrementare il numero \var{n}
-di file descriptor attivi da controllare e ad eseguire (\texttt{\small 33}) la
-lettura, ed in caso di errore (\texttt{\small 34--37}) al solito lo si
-notificherà uscendo immediatamente. Qualora invece si ottenga una condizione
-di end-of-file (\texttt{\small 38--47}) si provvederà a chiudere
-(\texttt{\small 39}) anche il nostro capo del socket e a marcarlo
-(\texttt{\small 40}) nella struttura ad esso associata come inutilizzato.
-Infine dovrà essere ricalcolato (\texttt{\small 41--45}) un eventiale nuovo
-valore di \var{max\_fd}. L'ultimo passo è (\texttt{\small 46}) chiudere il
-ciclo in quanto in questo caso non c'è più niente da riscrivere all'indietro
+qualora non lo sia. Se invece il file descriptor è in uso si verifica
+(\texttt{\small 29}) se c'è stata attività controllando il campo
+\var{revents}.
+
+Di nuovo se non si verifica la presenza di attività il ciclo si chiude subito,
+altrimenti si provvederà (\texttt{\small 30}) a decrementare il numero \var{n}
+di file descriptor attivi da controllare e ad eseguire (\texttt{\small 31}) la
+lettura, ed in caso di errore (\texttt{\small 32--35}) al solito lo si
+notificherà uscendo immediatamente. Qualora invece si ottenga una condizione
+di \textit{end-of-file} (\texttt{\small 36--45}) si provvederà a chiudere
+(\texttt{\small 37}) anche il nostro capo del socket e a marcarlo
+(\texttt{\small 38}) come inutilizzato nella struttura ad esso associata.
+Infine dovrà essere ricalcolato (\texttt{\small 39--43}) un eventuale nuovo
+valore di \var{max\_fd}. L'ultimo passo è chiudere (\texttt{\small 44}) il
+ciclo in quanto in questo caso non c'è più niente da riscrivere all'indietro
sul socket.
-Se invece si sono letti dei dati si provvede (\texttt{\small 48}) ad
+Se invece si sono letti dei dati si provvede (\texttt{\small 46}) ad
effettuarne la riscrittura all'indietro, con il solito controllo ed eventuale
-uscita e notifica in caso si errore (\texttt{\small 49--52}).
-
-Come si può notare la logica del programma è identica a quella vista in
-fig.~\ref{fig:TCP_SelectEchod} per l'analogo server basato su \func{select}; la
-sola differenza significativa è che in questo caso non c'è bisogno di
-rigenerare i file descriptor set in quanto l'uscita è indipendente dai dati in
-ingresso. Si applicano comunque anche a questo server le considerazioni finali
-di sez.~\ref{sec:TCP_serv_select}.
-
-
+uscita e notifica in caso di errore (\texttt{\small 47--51}).
+
+Come si può notare la logica del programma è identica a quella vista in
+fig.~\ref{fig:TCP_SelectEchod} per l'analogo server basato su \func{select};
+la sola differenza significativa è che in questo caso non c'è bisogno di
+rigenerare i \textit{file descriptor set} in quanto l'uscita è indipendente
+dai dati in ingresso. Si applicano comunque anche a questo server le
+considerazioni finali di sez.~\ref{sec:TCP_serv_select}.
+
+
+%\subsection{\textit{I/O multiplexing} con \textit{epoll}}
+%\label{sec:TCP_serv_epoll}
+
+%Da fare.
+
+% TODO fare esempio con epoll
+
+
+
+% LocalWords: socket TCP client dell'I multiplexing stream three way handshake
+% LocalWords: header stack kernel SYN ACK URG syncronize sez bind listen fig
+% LocalWords: accept connect active acknowledge l'acknowledge nell'header MSS
+% LocalWords: sequence number l'acknowledgement dell'header options l'header
+% LocalWords: option MMS segment size MAXSEG window advertised Mbit sec nell'
+% LocalWords: timestamp RFC long fat close of l'end l'ACK half shutdown CLOSED
+% LocalWords: netstat SENT ESTABLISHED WAIT IPv Ethernet piggybacking UDP MSL
+% LocalWords: l'overhead Stevens Lifetime router hop limit TTL to live RST SSH
+% LocalWords: routing dell'MSL l'IP multitasking well known port ephemeral BSD
+% LocalWords: ports dall' IANA Assigned Authority like glibc netinet IPPORT AF
+% LocalWords: RESERVED USERRESERVED rsh rlogin pair socketpair Local Address
+% LocalWords: Foreing DNS caching INADDR ANY multihoming loopback ssh fuser ip
+% LocalWords: lsof SOCK sys int sockfd const struct sockaddr serv addr socklen
+% LocalWords: addrlen errno EBADF descriptor EINVAL ENOTSOCK EACCES EADDRINUSE
+% LocalWords: EADDRNOTAVAIL EFAULT ENOTDIR ENOENT ENOMEM ELOOP ENOSR EROFS RPC
+% LocalWords: portmapper htonl tab endianness BROADCAST broadcast any extern fd
+% LocalWords: ADRR INIT DGRAM SEQPACKET servaddr ECONNREFUSED ETIMEDOUT EAGAIN
+% LocalWords: ENETUNREACH EINPROGRESS EALREADY EAFNOSUPPORT EPERM EISCONN proc
+% LocalWords: sysctl filesystem syn retries reset ICMP backlog EOPNOTSUPP RECV
+% LocalWords: connection queue dell'ACK flood spoofing syncookies SOMAXCONN CR
+% LocalWords: RDM EWOULDBLOCK firewall ENOBUFS EINTR EMFILE ECONNABORTED NULL
+% LocalWords: ESOCKTNOSUPPORT EPROTONOSUPPORT ERESTARTSYS connected listening
+% LocalWords: DECnet read write NONBLOCK fcntl getsockname getpeername name ps
+% LocalWords: namelen namlen ENOTCONN exec inetd POSIX daytime FullRead count
+% LocalWords: BUF FullWrite system call INET perror htons inet pton ctime FTP
+% LocalWords: fputs carriage return line feed superdemone daytimed sleep fork
+% LocalWords: daemon cunc logging list conn sock exit snprintf ntop ntohs echo
+% LocalWords: crash superserver L'RFC first ClientEcho stdin stdout fgets main
+% LocalWords: MAXLINE initd echod ServEcho setgid short nogroup nobody setuid
+% LocalWords: demonize PrintErr syslog wrapper log error root RTT EOF ctrl ack
+% LocalWords: while SIGCHLD Signal RESTART sigaction SignalRestart SigHand win
+% LocalWords: flags select recvfrom debug second compat waiting Nsec ENETDOWN
+% LocalWords: EPROTO ENOPROTOOPT EHOSTDOWN ENONET EHOSTUNREACH LINGER tcpdump
+% LocalWords: ECONNRESET advertising PSH SIGTERM strace SIGPIPE gets tcp ARP
+% LocalWords: cache anarres destination unreachable l'I low watermark RCVLOWAT
+% LocalWords: SNDLOWAT third fset maxfd fileno ISSET closed how SHUT RD WR eof
+% LocalWords: RDWR fifo Trip ping fourth CLR sull'I SETSIZE nread break Denial
+% LocalWords: Service poll POLLIN POLLRDNORM POLLPRI POLLRDBAND POLLOUT events
+% LocalWords: POLLHUP POLLERR revents pollfd Di scaling SYNCNT DoS
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "gapil"
%%% End:
+
projects / gapil.git / blobdiff