X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=elemtcp.tex;h=b074cb0fbb39a6712b371d3d2a440349284f9a26;hp=7929fcca6c6e400e0606c5e75a0f1cfc0f7728db;hb=d47f15496fa85c8ec22edcde608f2665ec5b95ae;hpb=09fff83335c84e1290f725341b0959344e5a7b03 diff --git a/elemtcp.tex b/elemtcp.tex index 7929fcc..b074cb0 100644 --- a/elemtcp.tex +++ b/elemtcp.tex @@ -1,80 +1,87 @@ -\chapter{Socket TCP elementari} -\label{cha:elem_TCP_sock} +%% elemtcp.tex +%% +%% Copyright (C) 2000-2002 Simone Piccardi. Permission is granted to +%% copy, distribute and/or modify this document under the terms of the GNU Free +%% Documentation License, Version 1.1 or any later version published by the +%% Free Software Foundation; with the Invariant Sections being "Prefazione", +%% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the +%% license is included in the section entitled "GNU Free Documentation +%% License". +%% +\chapter{Socket TCP} +\label{cha:TCP_socket} -In questo capitolo inizieremo ad approndire la conoscenza dei socket TCP, -tratteremo qui dunque il funzionamento delle varie funzioni che si sono usate -nei due esempi elementari forniti in precedenza (vedi \ref{sec:net_cli_sample} -e \ref{sec:net_serv_sample}), previa una descrizione delle principali -caratteristiche del funzionamento di una connessione TCP. +In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP, +iniziando con una descrizione delle principali caratteristiche del +funzionamento di una connessione TCP. Tratteremo poi le varie funzioni che +servono alla creazione di una connessione fra un server elementare ed il suo +client, fornendo poi alcuni esempi di applicazione elementare. -La seconda parte del capitolo sarà poi dedicata ad una riscrittura -dell'esempio precedente per trasformarlo in una prima applicazione -client/server semplice, ma completa, che implementi il servizio standard -\texttt{time} su TCP (vedremo in seguito un esempio anche con UDP). \section{Il funzionamento di una connessione TCP} -\label{sec:TCPel_connession} +\label{sec:TCP_connession} -Prima di entrare nei dettagli di come si usano le varie funzioni dei socket -che operano con TCP, è fondamentale capire alcune basi del funzionamento del -protocollo, ed in particolare su come si stabilisce una connessione, come la -si conclude e qual'è il significato dei vari stati del protocollo ad essa -connessi. +Prima di entrare nei dettagli delle singole funzioni usate nelle applicazioni +che utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del +funzionamento del protocollo, poiché questa conoscenza è essenziale per +comprendere il comportamento di dette funzioni per questo tipo di socket, ed +il relativo modello di programmazione. -La conoscenza del funzionamento del protocollo è infatti essenziale per capire -il modello di programmazione ed il funzionamento delle API. In tutto questo è -di grande aiuto il programma \texttt{netstat}, che useremo per mostrare lo -stato in cui si trova ciascuna connessione attiva. +Si ricordi che il protocollo TCP serve a creare degli \textit{stream socket}, +cioè una forma di canale di comunicazione che stabilisce una connessione +stabile fra due stazioni, in modo che queste possano scambiarsi dei dati. In +questa sezione ci concentreremo sulle modalità con le quali il protocollo dà +inizio e conclude una connessione e faremo inoltre un breve accenno al +significato di alcuni dei vari \textsl{stati} ad essa associati. -\subsection{La creazione della connessione: il \textit{three way handushake}} -\label{sec:TCPel_conn_cre} +\subsection{La creazione della connessione: il \textit{three way handshake}} +\label{sec:TCP_conn_cre} -Lo scenario tipico che si verifica quando si deve stabilire una connessione -TCP (lo stesso usato negli esempi elementari \ref{fig:net_cli_code} e -\ref{fig:net_serv_code}) la successione degli eventi è la -seguente: - -\begin{itemize} +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 \secref{sec:tcp_protocol}).} di dati che vengono +scambiati) che porta alla creazione di una connessione è la seguente: + +\begin{enumerate} \item Il server deve essere preparato per accettare le connessioni in arrivo; - il procedimento si chiama \textsl{apertura passiva} del socket (da - \textit{passive open}); questo viene fatto chiamando la sequenza di funzioni - \texttt{socket}, \texttt{bind} e \texttt{listen}. Infine il server chiama la - funzione \texttt{accept} e il processo si blocca in attesa di connessioni. + il procedimento si chiama \textsl{apertura passiva} del socket (in inglese + \textit{passive open}). Questo viene fatto chiamando la sequenza di funzioni + \func{socket}, \func{bind} e \func{listen}. Completata l'apertura passiva il + server chiama la funzione \func{accept} e il processo si blocca in attesa di + connessioni. \item Il client richiede l'inizio della connessione usando la funzione - \texttt{connect}, attraverso un procedimento che viene chiamato + \func{connect}, attraverso un procedimento che viene chiamato \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di - \texttt{connect} blocca il processo e causa l'invio da parte del client di - un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità - elementare di dati trasmessa dal protocollo TCP al livello superiore; - tutti i segmenti hanno un header che contiene le informazioni che servono - allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel - che implementa il protocollo) per realizzare la comunicazione, fra questi - dati ci sono una serie di flag usati per gestire la connessione, come - \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi, - come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a - funzioni particolari del protocollo e danno il nome al segmento, (per - maggiori dettagli vedere \ref{cha:tcp_protocol})}, in sostanza viene - inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con - un numero di sequenza) e le opzioni di TCP. + \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. -\item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN} - del client, inoltre anche il server deve inviare il suo \texttt{SYN} al - client (e trasmettere il numero di sequenza iniziale) questo viene fatto - ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN} - \texttt{ACK} e sono settati. +\item 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 + ACK. \item una volta che il client ha ricevuto l'acknowledge dal server la funzione - \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del - \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di - quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione - è stabilita. -\end{itemize} - -Dato che per compiere tutto questo procedimento devono essere scambiati tre -pacchetti esso viene generalmente chiamato \textit{three way handshake}. In -\nfig\ si è rappresentato graficamente lo sequenza di scambio dei segmenti che + \func{connect} ritorna, l'ultimo passo è dare 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 \figref{fig:TCP_TWH} +si è rappresentata graficamente la sequenza di scambio dei segmenti che stabilisce la connessione. % Una analogia citata da R. Stevens per la connessione TCP è quella con il @@ -88,49 +95,53 @@ stabilisce la connessione. \begin{figure}[htb] \centering - - \caption{Il \textit{three way handshake} del TCP} - \label{fig:TCPel_TWH} + \includegraphics[width=10cm]{img/three_way_handshake} + \caption{Il \textit{three way handshake} del TCP.} + \label{fig:TCP_TWH} \end{figure} -Si noti che figura si sono riportati anche i \textsl{numeri di sequenza} -associati ai vari pacchetti; per gestire una connessione affidabile infatti il -protocollo TCP prevede nell'header la presenza di un \textit{sequence number} -a 32 bit che identifica a quale byte nella sequenza dello stream corrisponde -il primo byte dei dati contenuti nel segmento. +Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche +riportati in \figref{fig:TCP_TWH}); per gestire una connessione affidabile +infatti il protocollo TCP prevede nell'header la presenza di un numero a 32 +bit (chiamato appunto \textit{sequence number}) che identifica a quale byte +nella sequenza del flusso corrisponde il primo byte della sezione dati +contenuta nel segmento. Il numero di sequenza di ciascun segmento viene calcolato a partire da un -numero di sequenza iniziale generato in maniera casuale del kernel all'inizio -della connessione e trasmesso con il SYN; l'acknowledgement di ciascun -segmento viene effettuato dall'altro capo della connessione settando il flag -\texttt{ACK} e restituendo nell'apposito campo dell'header un +\textsl{numero di sequenza iniziale} generato in maniera casuale del kernel +all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di +ciascun segmento viene effettuato dall'altro capo della connessione impostando +il flag ACK e restituendo nell'apposito campo dell'header un \textit{acknowledge number}) pari al numero di sequenza che il ricevente si aspetta di ricevere con il pacchetto successivo; dato che il primo pacchetto SYN consuma un byte, nel \textit{three way handshake} il numero di acknowledge è sempre pari al numero di sequenza iniziale incrementato di uno; lo stesso -varrà anche (vedi \nfig) per l'acknowledgement di un FIN. +varrà anche (vedi \figref{fig:TCP_close}) per l'acknowledgement di un FIN. \subsection{Le opzioni TCP.} -\label{sec:TCPel_TCP_opt} +\label{sec:TCP_TCP_opt} -Ciascun SYN può contenere delle opzioni per il TCP (le cosiddette \textit{TCP - options}, che vengono inserite fra l'header e i dati) che servono a regolare -la connessione. Normalmente vengono usate le seguenti opzioni: +Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP +(le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i +dati) che servono a comunicare all'altro capo una serie di parametri utili a +regolare la connessione. Normalmente vengono usate le seguenti opzioni: \begin{itemize} -\item \textit{MSS option} Sta per \textit{maximum segment size}, con questa - opzione ciascun capo della connessione annuncia all'altro il massimo +\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 - connesione corrente. È possibile leggere e scrivere questo valore attraverso - l'opzione del socket \texttt{TCP\_MAXSEG}. + connessione corrente. È possibile leggere e scrivere questo valore + attraverso l'opzione del socket \const{TCP\_MAXSEG}. -\item \textit{window scale option} come spiegato in \ref{cha:tcp_protocol} il - protocollo TCP implementa il controllo di flusso attraverso una +\item \textit{window scale option}, %come spiegato in \secref{sec:tcp_protocol} + il protocollo TCP implementa il controllo di flusso attraverso una \textsl{finestra annunciata} (\textit{advertized window}) con la quale ciascun capo della comunicazione dichiara quanto spazio disponibile ha in - memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può - indicare un massimo di 65535 bytes; ma alcuni tipi di connessione come - quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi + 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 @@ -138,11 +149,11 @@ la connessione. Normalmente vengono usate le seguenti opzioni: la compatibilità con delle vecchie implementazioni del protocollo la procedura che la attiva prevede come negoziazione che l'altro capo della connessione riconosca esplicitamente l'opzione inserendola anche lui nel - suo SYN di risposta dell'apertura della connessione} per la connessione - corrente (espresso come numero di bit cui shiftare a sinistra il valore - della finestra annunciata). + 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 +\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. @@ -150,109 +161,1762 @@ la connessione. Normalmente vengono usate le seguenti opzioni: \end{itemize} La MSS è generalmente supportata da quasi tutte le implementazioni del -protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni; +protocollo, le ultime due opzioni (trattate +nell'\href{http://www.ietf.org/rfc/rfc1323.txt}{RFC~1323}) sono meno comuni; vengono anche dette \textit{long fat pipe options} dato che questo è il nome che viene dato alle connessioni caratterizzate da alta velocità o da ritardi -elevati. - +elevati. In ogni caso Linux supporta pienamente entrambe le opzioni. \subsection{La terminazione della connessione} -\label{sec:TCPel_conn_term} +\label{sec:TCP_conn_term} Mentre per creare una connessione occorre un interscambio di tre segmenti, la -procedura di chiusura ne richede ben quattro; in questo caso la successione -degli eventi è la seguente: +procedura di chiusura ne richiede quattro; ancora una volta si può fare +riferimento al codice degli esempi \figref{fig:TCP_daytime_client_code} e +\figref{fig:TCP_daytime_iter_server_code}, in questo caso la successione degli +eventi è la seguente: \begin{enumerate} -\item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando - l'avvio a quella che viene chiamata \textsl{chiusura attiva} (da +\item Un processo ad uno dei due capi chiama la funzione \func{close}, dando + l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o \textit{active close}). Questo comporta l'emissione di un segmento FIN, che significa che si è finito con l'invio dei dati sulla connessione. \item L'altro capo della connessione riceve il FIN ed esegue la - \textit{chiusura passiva} (da \textit{passive close}); al FIN, come per - tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN - viene passato al processo che ha aperto il socket come un end of file sulla - lettura (dopo che ogni altro eventuale dato rimasto in coda è stato - ricevuto), dato che il ricevimento di un FIN significa che non si + \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 Dopo un certo tempo anche il secondo processo chiamerà la funzione - \texttt{close} sul proprio socket, causando l'emissione di un altro segmento + \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. \end{enumerate} - Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione -normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune -sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è -detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano -accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo -sequenza di scambio dei segmenti che stabilisce la connessione. +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 +\figref{fig:TCP_close} si è rappresentato graficamente lo sequenza di +scambio dei segmenti che conclude la connessione. \begin{figure}[htb] - \centering - - \caption{Il \textit{three way handshake} del TCP} - \label{fig:TCPel_TWH} + \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 possibile -che si mantenga un flusso di dati dal capo della connessione che sta eseguendo -la chiusura passiva a quello che sta eseguendo la chiusura attiva. Nella -sequenza indicata i dati verrebbero persi, dato che si è chiuso il socket, ma -esistono situazione in cui si vuole che avvenga proprio questo, che è chiamato -\texit{half-close}, per cui torneremo su questo aspetto e su come utilizzarlo -più avanti, quando parleremo della funzione \texttt{shutdown}. +Si noti che, nella sequenza di chiusura, fra i passi 2 e 3, è in teoria +possibile che si mantenga un flusso di dati dal capo della connessione che +deve ancora eseguire la chiusura passiva a quello che sta eseguendo la +chiusura attiva. Nella sequenza indicata i dati verrebbero persi, dato che si +è chiuso il socket dal lato che esegue la chiusura attiva; esistono tuttavia +situazioni in cui si vuole poter sfruttare questa possibilità, usando una +procedura che è chiamata \textit{half-close}; torneremo su questo aspetto e su +come utilizzarlo in \secref{xxx_shutdown}, quando parleremo della funzione +\func{shutdown}. La emissione del FIN avviene quando il socket viene chiuso, questo però non -avviene solo per la chiamata della funzione \texttt{close}, ma anche alla -terminazione di un processo, il che vuol dire che se un processo viene -terminato da un segnale tutte le connessioni aperte verranno chiuse. +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 \secref{sec:TCPsimp_echo}) sia stato il client ad +eseguire la chiusura attiva, nella realtà questa può essere eseguita da uno +qualunque dei due capi della comunicazione (come nell'esempio di +\figref{fig:TCP_daytime_iter_server_code}), e anche se il caso più comune +resta quello del client, ci sono alcuni servizi, il principale dei quali è +l'HTTP, per i quali è il server ad effettuare la chiusura attiva. \subsection{Un esempio di connessione} -\label{sec:TCPel_conn_dia} +\label{sec:TCP_conn_dia} + +Come abbiamo visto le operazioni del TCP nella creazione e conclusione di una +connessione sono piuttosto complesse, ed abbiamo esaminato soltanto quelle +relative ad un andamento normale. In \secref{sec:TCP_states} vedremo con +maggiori dettagli che una connessione può assumere vari stati, che ne +caratterizzano il funzionamento, e che sono quelli che vengono riportati dal +comando \cmd{netstat}, per ciascun socket TCP aperto, nel campo +\textit{State}. -Le operazioni del TCP nella creazione e conclusione di una connessione sono -specificate attraverso il diagramma di transizione degli stati riportato in -\nfig. TCP prevede l'esistenza di 11 diversi stati per una connessione ed un -insieme di regole per le transizioni da uno stato all'altro basate sullo stato -corrente e sul tipo di segmetno ricevuto. +Non possiamo affrontare qui una descrizione completa del funzionamento del +protocollo; un approfondimento sugli aspetti principali si trova in +\secref{sec:tcp_protocol}, ma per una trattazione completa il miglior +riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un +semplice esempio di connessione e le transizioni che avvengono nei due casi +appena citati (creazione e terminazione della connessione). +In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una +applicazione esegue una apertura attiva il TCP emette un SYN e lo stato +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 +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 +stato \texttt{LISTEN} in cui vengono accettate le connessioni. + +Dallo stato \texttt{ESTABLISHED} si può uscire in due modi; se un'applicazione +chiama la funzione \texttt{close} prima di aver ricevuto un +\textit{end-of-file} (chiusura attiva) la transizione è verso lo stato +\texttt{FIN\_WAIT\_1}; se invece l'applicazione riceve un FIN nello stato +\texttt{ESTABLISHED} (chiusura passiva) la transizione è verso lo stato +\texttt{CLOSE\_WAIT}. + +In \figref{fig:TCP_conn_example} è riportato lo schema dello scambio dei +pacchetti che avviene per una un esempio di connessione, insieme ai vari stati +che il protocollo viene ad assumere per i due lati, server e client. + +\begin{figure}[htb] + \centering + \includegraphics[width=9cm]{img/tcp_connection} + \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). + +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 che il server è sufficientemente veloce a costruire la risposta; in +caso contrario si avrebbe prima l'emissione di un ACK e poi l'invio della +risposta. + +Infine si ha lo scambio dei quattro segmenti che terminano la connessione +secondo quanto visto in \secref{sec: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 +fosse usato UDP si sarebbe dovuto trasferire la gestione di tutta una serie di +dettagli (come la verifica della ricezione dei pacchetti) dal livello del +trasporto all'interno dell'applicazione. + +Quello che è bene sempre tenere presente è allora quali sono le esigenze che +si hanno in una applicazione di rete, perché non è detto che TCP sia la +miglior scelta in tutti i casi (ad esempio se si devono solo scambiare dati +già organizzati in piccoli pacchetti l'overhead aggiunto può essere eccessivo) +per questo esistono applicazioni che usano UDP e lo fanno perché nel caso +specifico le sue caratteristiche di velocità e compattezza nello scambio dei +dati rispondono meglio alle esigenze che devono essere affrontate. \subsection{Lo stato \texttt{TIME\_WAIT}} -\label{sec:TCPel_time_wait} +\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 +comune trovare domande su come sia possibile evitare che un'applicazione resti +in questo stato lasciando attiva una connessione ormai conclusa; la risposta è +che non deve essere fatto, ed il motivo cercheremo di spiegarlo adesso. + +Come si è visto nell'esempio precedente (vedi \figref{fig:TCP_conn_example}) +\texttt{TIME\_WAIT} è lo stato finale in cui il capo di una connessione che +esegue la chiusura attiva resta prima di passare alla chiusura definitiva +della connessione. Il tempo in cui l'applicazione resta in questo stato deve +essere due volte la MSL (\textit{Maximum Segment Lifetime}). + +La MSL è la stima del massimo periodo di tempo che un pacchetto IP può vivere +sulla rete; questo tempo è limitato perché ogni pacchetto IP può essere +ritrasmesso dai router un numero massimo di volte (detto \textit{hop limit}). +Il numero di ritrasmissioni consentito è indicato dal campo TTL dell'header di +IP (per maggiori dettagli vedi \secref{sec:IP_xxx}), e viene decrementato ad +ogni passaggio da un router; quando si annulla il pacchetto viene scartato. +Siccome il numero è ad 8 bit il numero massimo di ``\textsl{salti}'' è di 255, +pertanto anche se il TTL (da \textit{time to live}) non è propriamente un +limite sul tempo di vita, si stima che un pacchetto IP non possa restare nella +rete per più di MSL secondi. + +Ogni implementazione del TCP deve scegliere un valore per la MSL +(l'\href{http://www.ietf.org/rfc/rfc1122.txt}{RFC~1122} raccomanda 2 minuti, +Linux usa 30 secondi), questo comporta una durata dello stato +\texttt{TIME\_WAIT} che a seconda delle implementazioni può variare fra 1 a 4 +minuti. + +Lo stato \texttt{TIME\_WAIT} viene utilizzato dal protocollo per due motivi +principali: +\begin{enumerate} +\item implementare in maniera affidabile la terminazione della connessione + in entrambe le direzioni. +\item consentire l'eliminazione dei segmenti duplicati dalla rete. +\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 +durata di questo stato. + +Il primo dei due motivi precedenti si può capire tornando a +\figref{fig:TCP_conn_example}: assumendo che l'ultimo ACK della sequenza +(quello del capo che ha eseguito la chiusura attiva) vanga perso, chi esegue +la chiusura passiva non ricevendo risposta rimanderà un ulteriore FIN, per +questo motivo chi esegue la chiusura attiva deve mantenere lo stato della +connessione per essere in grado di reinviare l'ACK e chiuderla correttamente. +Se non fosse così la risposta sarebbe un RST (un altro tipo si segmento) che +verrebbe interpretato come un errore. + +Se il TCP deve poter chiudere in maniera pulita entrambe le direzioni della +connessione allora deve essere in grado di affrontare la perdita di uno +qualunque dei quattro segmenti che costituiscono la chiusura. Per questo +motivo lo stato \texttt{TIME\_WAIT} deve essere mantenuto anche dopo l'invio +dell'ultimo ACK per poter essere in grado di poterne gestire l'eventuale +ritrasmissione in caso di perdita. + +Il secondo motivo è più complesso da capire, e necessita di una spiegazione +degli scenari in cui accade che i pacchetti 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 +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 +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. + +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. + +Allora per capire la seconda ragione per l'esistenza dello stato +\texttt{TIME\_WAIT} si consideri il caso seguente: si supponga di avere una +connessione fra l'IP \texttt{195.110.112.236} porta 1550 e l'IP +\texttt{192.84.145.100} porta 22, che questa venga chiusa e che poco dopo si +ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte +(quella che viene detta, essendo gli stessi porte e numeri IP, una nuova +\textsl{incarnazione} della connessione precedente); in questo caso ci si +potrebbe trovare con dei pacchetti duplicati relativi alla precedente +connessione che riappaiono nella nuova. + +Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere +creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT} +per un periodo di 2MSL, in modo da attendere MSL secondi per essere sicuri che +tutti i pacchetti duplicati in arrivo siano stati ricevuti (e scartati) o che +nel frattempo siano stati eliminati dalla rete, e altri MSL secondi per essere +sicuri che lo stesso avvenga per le risposte nella direzione opposta. + +In questo modo, prima che venga creata una nuova connessione, il protocollo +TCP si assicura che tutti gli eventuali segmenti residui di una precedente +connessione, che potrebbero causare disturbi, siano stati eliminati dalla +rete. + + +\subsection{I numeri di porta} +\label{sec: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. +Per poter tenere distinte le diverse connessioni entrambi i protocolli usano i +\textsl{numeri di porta}, che fanno parte, come si può vedere in +\secref{sec:sock_sa_ipv4} e \secref{sec:sock_sa_ipv6} pure delle strutture +degli indirizzi del socket. + +Quando un client contatta un server deve poter identificare con quale dei vari +possibili server attivi intende parlare. Sia TCP che UDP definiscono un gruppo +di \textsl{porte conosciute} (le cosiddette \textit{well-known port}) che +identificano una serie di servizi noti (ad esempio la porta 22 identifica il +servizio \texttt{ssh}) effettuati da appositi server che rispondono alle +connessioni verso tali porte. + +D'altra parte un client non ha necessità di usare un numero di porta +specifico, per cui in genere vengono usate le cosiddette \textsl{porte + effimere} (o \textit{ephemeral ports}) cioè porte a cui non è assegnato +nessun servizio noto e che vengono assegnate automaticamente dal kernel alla +creazione della connessione. Queste sono dette effimere in quanto vengono +usate solo per la durata della connessione, e l'unico requisito che deve +essere soddisfatto è che ognuna di esse sia assegnata in maniera univoca. + +La lista delle porte conosciute è definita +dall'\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 corrente si può trovare all'indirizzo +\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}); inoltre +in un sistema unix-like un analogo elenco viene mantenuto nel file +\file{/etc/services}, con la corrispondenza fra i vari numeri di porta ed il +nome simbolico del servizio. I numeri sono divisi in tre intervalli: + +\begin{enumerate} +\item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono + controllate e assegnate dalla IANA. Se è possibile la stessa porta è + assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22 + è assegnata a ssh su entrambi i protocolli, anche se viene usata solo dal + TCP). + +\item \textsl{le porte registrate}. I numeri da 1024 a 49151. Queste porte non + sono controllate dalla IANA, che però registra ed elenca chi usa queste + porte come servizio agli utenti. Come per le precedenti si assegna una porta + ad un servizio sia per TCP che UDP anche se poi il servizio è implementato + solo su TCP. Ad esempio X Window usa le porte TCP e UDP dal 6000 al 6063 + anche se il protocollo è implementato solo tramite TCP. + +\item \textsl{le porte private} o \textsl{dinamiche}. I numeri da 49152 a + 65535. La IANA non dice nulla riguardo a queste porte che pertanto + sono i candidati naturali ad essere usate come porte effimere. +\end{enumerate} + +In realtà rispetto a quanto indicato +nell'\href{http://www.ietf.org/rfc/rfc1700.txt}{RFC~1700} i vari sistemi hanno +fatto scelte diverse per le porte effimere, in particolare in +\figref{fig:TCP_port_alloc} sono riportate quelle di BSD e Linux. Nel caso di +Linux poi la scelta fra i due intervalli possibili viene fatta dinamicamente a +seconda della memoria a disposizione del kernel per gestire le relative +tabelle. + +\begin{figure}[!htb] + \centering + \includegraphics[width=15cm]{img/port_alloc} + \caption{Allocazione dei numeri di porta.} + \label{fig:TCP_port_alloc} +\end{figure} + +I sistemi Unix hanno inoltre il concetto di \textsl{porte riservate} (che +corrispondono alle porte con numero minore di 1024 e coincidono quindi con le +porte conosciute). La loro caratteristica è che possono essere assegnate a un +socket solo da un processo con i privilegi di root, per far si che solo +l'amministratore possa allocare queste porte per far partire i relativi +servizi. + +Si tenga conto poi che ci sono alcuni client (in particolare \cmd{rsh} e +\cmd{rlogin}) che richiedono una connessione su una porta riservata anche +dal lato client come parte dell'autenticazione. Questo viene fatto tramite la +funzione \func{rresvport} assegnando al socket una porta libera +nell'intervallo fra 512 e 1023. + +Data una connessione TCP si suole chiamare \textit{socket pair}\footnote{da + non confondere con la coppia di socket della omonima funzione + \func{socketpair} che fanno riferimento ad una coppia di socket sulla stessa + macchina, non ai capi di una connessione TCP.} la combinazione dei quattro +numeri che definiscono i due capi della connessione e cioè l'indirizzo IP +locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota. +Questa combinazione, che scriveremo usando una notazione del tipo +(\texttt{195.110.112.152:22}, \texttt{192.84.146.100:20100}), identifica +univocamente una connessione su internet. Questo concetto viene di solito +esteso anche a UDP, benché in questo caso non abbia senso parlare di +connessione. L'utilizzo del programma \cmd{netstat} permette di visualizzare +queste informazioni nei campi \textit{Local Address} e \textit{Foreing + Address}. + + +\subsection{Le porte ed il modello client/server} +\label{sec:TCP_port_cliserv} + +Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a +che fare con un'applicazione client/server (come quelle che scriveremo in +\secref{sec:TCP_daytime_application} e \secref{sec:TCP_echo_application}) +esamineremo cosa accade con le connessioni nel caso di un server TCP che deve +gestire connessioni multiple. + +Se eseguiamo un \cmd{netstat} su una macchina di prova (il cui indirizzo sia +\texttt{195.110.112.152}) potremo avere un risultato del tipo: +\begin{verbatim} +Active Internet connections (servers and established) +Proto Recv-Q Send-Q Local Address Foreign Address State +tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN +tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN +tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN +\end{verbatim} +essendo presenti 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 è +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, +indica il valore generico, e corrisponde al valore \const{INADDR\_ANY} +definito in \file{arpa/inet.h} (vedi \ref{tab:TCP_ipv4_addr}). + +Inoltre si noti come la porta e l'indirizzo di ogni eventuale connessione +esterna non sono specificati; in questo caso la \textit{socket pair} associata +al socket potrebbe essere indicata come (\texttt{*:22}, \texttt{*:*}), usando +anche per gli indirizzi l'asterisco come carattere che indica il valore +generico. + +Dato che in genere una macchina è associata ad un solo indirizzo IP, ci si può +chiedere che senso abbia l'utilizzo dell'indirizzo generico per specificare +l'indirizzo locale; ma a parte il caso di macchine che hanno più di un +indirizzo IP (il cosiddetto \textit{multihoming}) esiste sempre anche +l'indirizzo di loopback, per cui con l'uso dell'indirizzo generico si possono +accettare connessioni indirizzate verso uno qualunque degli indirizzi IP +presenti. Ma, come si può vedere nell'esempio con il DNS che è in ascolto +sulla porta 53, è possibile anche restringere l'accesso ad uno specifico +indirizzo, cosa che nel caso è fatta accettando solo connessioni che arrivino +sull'interfaccia di loopback. +Una volta che ci si vorrà collegare a questa macchina da un'altra, per esempio +quella con l'indirizzo \texttt{192.84.146.100}, si dovrà lanciare su +quest'ultima un client \cmd{ssh} per creare una connessione, e il kernel gli +assocerà una porta effimera (ad esempio la 21100), per cui la connessione sarà +espressa dalla socket pair (\texttt{192.84.146.100:21100}, +\texttt{195.110.112.152:22}). +Alla ricezione della richiesta dal client il server creerà un processo figlio +per gestire la connessione, se a questo punto eseguiamo nuovamente il +programma \cmd{netstat} otteniamo come risultato: +\begin{verbatim} +Active Internet connections (servers and established) +Proto Recv-Q Send-Q Local Address Foreign Address State +tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN +tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN +tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN +tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED +\end{verbatim} + +Come si può notare il server è ancora in ascolto sulla porta 22, però adesso +c'è un nuovo socket (con lo stato \texttt{ESTABLISHED}) che 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 +genere: +\begin{verbatim} +Active Internet connections (servers and established) +Proto Recv-Q Send-Q Local Address Foreign Address State +tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN +tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN +tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN +tcp 0 0 195.110.112.152:22 192.84.146.100:21100 ESTABLISHED +tcp 0 0 195.110.112.152:22 192.84.146.100:21101 ESTABLISHED +\end{verbatim} +cioè 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}.} 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{I numeri di porta} -\label{sec:TCPel_ports} \section{Le funzioni dei socket TCP} -\label{sec:TCPel_functions} +\label{sec:TCP_functions} + +In questa sezione descriveremo in dettaglio le varie funzioni necessarie per +l'uso dei socket TCP, con l'eccezione della funzione \func{socket} che è già +stata esaminata in dettaglio nel capitolo precedente in +\secref{sec:sock_socket}. + + +\subsection{La funzione \func{bind}} +\label{sec:TCP_func_bind} + +La funzione \funcd{bind} assegna un indirizzo locale ad un socket. È usata +cioè per specificare la prima parte dalla socket pair. Viene usata sul lato +server per specificare la porta (e gli eventuali indirizzi locali) su cui poi +ci si porrà in ascolto. Il prototipo della funzione è il seguente: +\begin{prototype}{sys/socket.h} +{int bind(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)} + + Assegna un indirizzo ad un socket. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 per un errore; + in caso di errore la variabile \var{errno} viene impostata secondo i + seguenti codici di errore: + \begin{errlist} + \item[\errcode{EBADF}] il file descriptor non è valido. + \item[\errcode{EINVAL}] il socket ha già un indirizzo assegnato. + \item[\errcode{ENOTSOCK}] il file descriptor non è associato ad un socket. + \item[\errcode{EACCES}] si è cercato di usare una porta riservata senza + sufficienti privilegi. + \item[\errcode{EADDRNOTAVAIL}] Il tipo di indirizzo specificato non è + disponibile. + \item[\errcode{EADDRINUSE}] qualche altro socket sta già usando l'indirizzo. + \end{errlist} + ed anche \errval{EFAULT} e per i socket di tipo \const{AF\_UNIX}, + \errval{ENOTDIR}, \errval{ENOENT}, \errval{ENOMEM}, \errval{ELOOP}, + \errval{ENOSR} e \errval{EROFS}.} +\end{prototype} + +Il primo argomento è un file descriptor ottenuto da una precedente chiamata a +\func{socket}, mentre il secondo e terzo argomento sono rispettivamente +l'indirizzo (locale) del socket e la dimensione della struttura che lo +contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}. + +Con il TCP la chiamata \func{bind} permette di specificare l'indirizzo, la +porta, entrambi o nessuno dei due. In genere i server utilizzano una porta +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. + In questo caso viene fatta assegnare dal kernel una porta effimera che poi + viene registrata presso il \textit{portmapper}; quest'ultimo è un altro + demone che deve essere contattato dai client per ottenere la porta effimera + su cui si trova il server.} che in genere viene identificato dalla porta su +cui risponde (l'elenco di queste porte, e dei relativi servizi, è in +\file{/etc/services}). + +Con \func{bind} si può assegnare un IP specifico ad un socket, purché questo +appartenga ad una interfaccia della macchina. Per un client TCP questo +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 dipende dalle +regole di instradamento usate per raggiungere il server). Se un server non +specifica il suo indirizzo locale il kernel userà come indirizzo di origine +l'indirizzo di destinazione specificato dal SYN del client. + +Per specificare un indirizzo generico, con IPv4 si usa il valore +\const{INADDR\_ANY}, il cui valore, come accennato in +\secref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio +\figref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione immediata +del tipo: \includecodesnip{listati/serv_addr_sin_addr.c} + +Si noti che si è usato \func{htonl} per assegnare il valore +\const{INADDR\_ANY}, anche se, essendo questo nullo, il riordinamento è +inutile. Si tenga presente comunque che tutte le costanti \val{INADDR\_} +(riportate in \tabref{tab:TCP_ipv4_addr}) sono definite secondo +l'\textit{endianess} della macchina, ed anche se esse possono essere +invarianti rispetto all'ordinamento dei bit, è comunque buona norma usare +sempre la funzione \func{htonl}. + +\begin{table}[htb] + \centering + \footnotesize + \begin{tabular}[c]{|l|l|} + \hline + \textbf{Costante} & \textbf{Significato} \\ + \hline + \hline + \const{INADDR\_ANY} & Indirizzo generico (\texttt{0.0.0.0})\\ + \const{INADDR\_BROADCAST}& Indirizzo di \textit{broadcast}.\\ + \const{INADDR\_LOOPBACK} & Indirizzo di \textit{loopback} + (\texttt{127.0.0.1}).\\ + \const{INADDR\_NONE} & Indirizzo errato.\\ + \hline + \end{tabular} + \caption{Costanti di definizione di alcuni indirizzi generici per IPv4.} + \label{tab:TCP_ipv4_addr} +\end{table} + +L'esempio precedente funziona correttamente con IPv4 poiché che l'indirizzo è +rappresentabile anche con un intero a 32 bit; non si può usare lo stesso +metodo con IPv6, in cui l'indirizzo deve necessariamente essere specificato +con una struttura, perché il linguaggio C non consente l'uso di una struttura +costante come operando a destra in una assegnazione. + +Per questo motivo nell'header \file{netinet/in.h} è definita una variabile +\const{in6addr\_any} (dichiarata come \direct{extern}, ed inizializzata dal +sistema al valore \const{IN6ADRR\_ANY\_INIT}) che permette di effettuare una +assegnazione del tipo: \includecodesnip{listati/serv_addr_sin6_addr.c} in +maniera analoga si può utilizzare la variabile \const{in6addr\_loopback} per +indicare l'indirizzo di \textit{loopback}, che a sua volta viene inizializzata +staticamente a \const{IN6ADRR\_LOOPBACK\_INIT}. + + + +\subsection{La funzione \func{connect}} +\label{sec:TCP_func_connect} + +La funzione \funcd{connect} è usata da un client TCP per stabilire la +connessione con un server TCP, il prototipo della funzione è il seguente: +\begin{prototype}{sys/socket.h} +{int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t addrlen)} + + Stabilisce una connessione fra due socket. + + \bodydesc{La funzione restituisce zero in caso di successo e -1 per un + errore, in caso di errore \var{errno} assumerà i 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 + \secref{sec:file_noblocking}) e la connessione non può essere conclusa + immediatamente. + \item[\errcode{EALREADY}] il socket è non bloccante (vedi + \secref{sec:file_noblocking}) e un tentativo precedente di connessione non + si è ancora concluso. + \item[\errcode{EAGAIN}] non ci sono più porte locali libere. + \item[\errcode{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi + corretta nel relativo campo. + \item[\errcode{EACCES}, \errcode{EPERM}] si è tentato di eseguire una + connessione ad un indirizzo broadcast senza che il socket fosse stato + abilitato per il broadcast. + \end{errlist} + altri errori possibili sono: \errval{EFAULT}, \errval{EBADF}, + \errval{ENOTSOCK}, \errval{EISCONN} e \errval{EADDRINUSE}.} +\end{prototype} + +Il primo argomento è un file descriptor ottenuto da una precedente chiamata a +\func{socket}, mentre il secondo e terzo argomento sono rispettivamente +l'indirizzo e la dimensione della struttura che contiene l'indirizzo del +socket, già descritta in \secref{sec:sock_sockaddr}. + +La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il +numero di porta del server a cui ci si vuole connettere, come mostrato +nell'esempio \secref{sec:TCP_daytime_client}, usando le funzioni illustrate in +\secref{sec:sock_addr_func}. + +Nel caso di socket TCP la funzione \func{connect} avvia il \textit{three way + 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. +% +% Le informazioni su tutte le opzioni impostabili via /proc stanno in +% Linux/Documentation/networking/ip-sysctl.txt +% +\item Il client riceve come risposta al SYN un RST significa che non c'è + 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 + ritorna non appena il RST viene ricevuto riportando un errore + \errcode{ECONNREFUSED}. + + Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente + dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono: + 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ò + 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 + \errcode{ENETUNREACH}. + +\end{enumerate} + +Se si fa riferimento al diagramma degli stati del TCP riportato in +\figref{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 è +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è, +come dice il nome, per metterlo in ascolto di eventuali connessioni; in +sostanza l'effetto della funzione è di portare il socket dallo stato +\texttt{CLOSED} a quello \texttt{LISTEN}. In genere si chiama la funzione in +un server dopo le chiamate a \func{socket} e \func{bind} e prima della +chiamata ad \func{accept}. Il prototipo della funzione, come definito dalla +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: + \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. + \end{errlist}} +\end{prototype} + +La funzione pone il socket specificato da \param{sockfd} in modalità passiva e +predispone una coda per le connessioni in arrivo di lunghezza pari a +\param{backlog}. La funzione si può applicare solo a socket di tipo +\const{SOCK\_STREAM} o \const{SOCK\_SEQPACKET}. + +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 \textit{three way handshake} non si è ancora concluso. + Questi socket sono tutti nello stato \texttt{SYN\_RECV}. +\item La coda delle connessioni complete (\textit{complete connection queue} + che contiene un ingresso per ciascun socket per il quale il three way + handshake è stato completato ma ancora \func{accept} non è ritornata. + Questi socket sono tutti nello stato \texttt{ESTABLISHED}. +\end{enumerate} + +Lo schema di funzionamento è descritto in \figref{fig:TCP_listen_backlog}: +quando arriva un SYN da un client il server crea una nuova voce nella coda +delle connessioni incomplete, e poi risponde con il SYN$+$ACK. La voce resterà +nella coda delle connessioni incomplete fino al ricevimento dell'ACK dal +client o fino ad un timeout. Nel caso di completamento del three way handshake +la voce viene spostata nella coda delle connessioni complete. Quando il +processo chiama la funzione \func{accept} (vedi \secref{sec:TCP_func_accept}) +la prima voce nella coda delle connessioni complete è passata al programma, o, +se la coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo +della prima connessione completa. + +\begin{figure}[htb] + \centering + \includegraphics[width=11cm]{img/tcp_listen_backlog} + \caption{Schema di funzionamento delle code delle connessioni complete ed + incomplete.} + \label{fig:TCP_listen_backlog} +\end{figure} + +Storicamente il valore del parametro \param{backlog} era corrispondente al +massimo valore della somma del numero di voci possibili per ciascuna delle due +code. Stevens in \cite{UNP1} riporta che BSD ha sempre applicato un fattore di +1.5 a detto valore, e fornisce una tabella con i risultati ottenuti con vari +kernel, compreso Linux 2.0, che mostrano le differenze fra diverse +implementazioni. + +In Linux il significato di questo valore è cambiato a partire dal kernel 2.2 +per prevenire l'attacco chiamato \textit{syn flood}. Questo si basa +sull'emissione da parte dell'attaccante di un grande numero di pacchetti SYN +indirizzati verso una porta, forgiati con indirizzo IP fasullo\footnote{con la + tecnica che viene detta \textit{ip spoofing}.} così che i SYN$+$ACK vanno +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 +\secref{sec:proc_environ}). + +Stevens tratta accuratamente questo argomento in \cite{UNP1}, con esempi presi +da casi reali su web server, ed in particolare evidenzia come non sia più vero +che il compito principale della coda sia quello di gestire il caso in cui il +server è occupato fra chiamate successive alla \func{accept} (per cui la coda +più occupata sarebbe quella delle connessioni completate), ma piuttosto quello +di gestire la presenza di un gran numero di SYN in attesa di concludere il +three way handshake. + +Infine va messo in evidenza che, nel caso di socket TCP, quando un SYN arriva +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. + + +\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 \textit{three way handshake}, la +funzione restituisce un nuovo socket descriptor su cui si potrà operare per +effettuare la comunicazione. Se non ci sono connessioni completate il processo +viene messo in attesa. Il prototipo della funzione è il seguente: +\begin{prototype}{sys/socket.h} +{int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)} + + Accetta una connessione sul socket specificato. + + \bodydesc{La funzione restituisce un numero di socket descriptor positivo in + caso di successo e -1 in caso di errore, nel qual caso \var{errno} viene + impostata ai seguenti valori: + + \begin{errlist} + \item[\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 + come non bloccante (vedi \secref{sec:file_noblocking}), e non ci sono + connessioni in attesa di essere accettate. + \item[\errcode{EPERM}] Le regole del firewall non consentono la connessione. + \item[\errcode{ENOBUFS}, \errcode{ENOMEM}] questo spesso significa che + l'allocazione della memoria è limitata dai limiti sui buffer dei socket, + non dalla memoria di sistema. + \item[\errcode{EINTR}] La funzione è stata interrotta da un segnale. + \end{errlist} + Inoltre possono essere restituiti gli errori di rete relativi al nuovo + socket, diversi a secondo del protocollo, come: \errval{EMFILE}, + \errval{EINVAL}, \errval{ENOSR}, \errval{ENOBUFS}, \errval{EFAULT}, + \errval{EPERM}, \errval{ECONNABORTED}, \errval{ESOCKTNOSUPPORT}, + \errval{EPROTONOSUPPORT}, \errval{ETIMEDOUT}, \errval{ERESTARTSYS}.} +\end{prototype} + +La funzione 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. + +Se la funzione ha successo restituisce il descrittore di un nuovo socket +creato dal kernel (detto \textit{connected socket}) a cui viene associata la +prima connessione completa (estratta dalla relativa coda, vedi +\secref{sec:TCP_func_listen}) che il client ha effettuato verso il socket +\param{sockfd}. Quest'ultimo (detto \textit{listening socket}) è quello creato +all'inizio e messo in ascolto con \func{listen}, e non viene toccato dalla +funzione. Se non ci sono connessioni pendenti da accettare la funzione mette +in attesa il processo\footnote{a meno che non si sia impostato il socket per + essere non bloccante (vedi \secref{sec:file_noblocking}), nel qual caso + ritorna con l'errore \errcode{EAGAIN}. Torneremo su questa modalità di + operazione in \secref{sec:xxx_sock_noblock}.} fintanto che non ne arriva +una. + +La funzione può essere usata solo con socket che supportino la connessione +(cioè di tipo \const{SOCK\_STREAM}, \const{SOCK\_SEQPACKET} o +\const{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma +esplicita della connessione,\footnote{attualmente in Linux solo DECnet ha + questo comportamento.} la funzione opera solo l'estrazione dalla coda delle +connessioni, la conferma della connessione viene eseguita implicitamente dalla +prima chiamata ad una \func{read} o una \func{write}, mentre il rifiuto della +connessione viene eseguito con la funzione \func{close}. + +È da chiarire che Linux presenta un comportamento diverso nella gestione degli +errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione +\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici +di errore per \func{accept}, per cui l'applicazione deve tenerne conto ed +eventualmente ripetere la chiamata alla funzione come per l'errore di +\errcode{EAGAIN}. Un'altra differenza con BSD è che la funzione non fa +ereditare al nuovo socket i flag del socket originale, come +\const{O\_NONBLOCK},\footnote{ed in generale tutti quelli che si possono + impostare con \func{fcntl}, vedi \secref{sec:file_fcntl}.} che devono essere +rispecificati ogni volta. Tutto questo deve essere tenuto in conto se si +devono scrivere programmi portabili. + +Il meccanismo di funzionamento di \func{accept} è essenziale per capire il +funzionamento di un server: in generale infatti c'è sempre un solo socket in +ascolto, detto per questo \textit{listening socket}, che resta per tutto il +tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai +nuovi socket, detti \textit{connected socket}, ritornati da \func{accept}, che +si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono +utilizzati per lo scambio dei dati, che avviene su di essi, fino alla chiusura +della connessione. Si può riconoscere questo schema anche nell'esempio +elementare di \figref{fig:TCP_daytime_iter_server_code}, dove per ogni +connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei +dati. -\subsection{La funzione \texttt{connect}} -\label{sec:TCPel_func_connect} -\subsection{La funzione \texttt{bind}} -\label{sec:TCPel_func_bind} +\subsection{Le funzioni \func{getsockname} e \func{getpeername}} +\label{sec:TCP_get_names} + +Oltre a tutte quelle viste finora, dedicate all'utilizzo dei socket, esistono +alcune funzioni ausiliarie che possono essere usate per recuperare alcune +informazioni relative ai socket ed alle connessioni ad essi associate. Le due +funzioni più elementari sono queste, che vengono usate per ottenere i dati +relativi alla socket pair associata ad un certo socket. + +La prima funzione è \funcd{getsockname} e serve ad ottenere l'indirizzo locale +associato ad un socket; il suo prototipo è: +\begin{prototype}{sys/socket.h} + {int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)} + Legge l'indirizzo locale di un socket. + +\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore. I codici di errore restituiti in \var{errno} sono i seguenti: + \begin{errlist} + \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor + valido. + \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket. + \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per + eseguire l'operazione. + \item[\errcode{EFAULT}] l'indirizzo \param{name} non è valido. + \end{errlist}} +\end{prototype} + +La funzione restituisce la struttura degli indirizzi del socket \param{sockfd} +nella struttura indicata dal puntatore \param{name} la cui lunghezza è +specificata tramite l'argomento \param{namlen}. Quest'ultimo viene passato +come indirizzo per avere indietro anche il numero di byte effettivamente +scritti nella struttura puntata da \param{name}. Si tenga presente che se si è +utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà +troncato. + +La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un +socket; ad esempio può essere usata da un client (che usualmente non chiama +\func{bind}) per ottenere numero IP e porta locale associati al socket +restituito da una \func{connect}, o da un server che ha chiamato \func{bind} +su un socket usando 0 come porta locale per ottenere il numero di porta +effimera assegnato dal kernel. + +Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se +chiamata dopo il completamento di una connessione sul socket restituito da +\func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a +quella connessione. + +Tutte le volte che si vuole avere l'indirizzo remoto di un socket si usa la +funzione \funcd{getpeername}, il cui prototipo è: +\begin{prototype}{sys/socket.h} + {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)} + Legge l'indirizzo remoto di un socket. + + \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di + errore. I codici di errore restituiti in \var{errno} sono i seguenti: + \begin{errlist} + \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor + valido. + \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket. + \item[\errcode{ENOTCONN}] il socket non è connesso. + \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per + eseguire l'operazione. + \item[\errcode{EFAULT}] l'argomento \param{name} punta al di fuori dello + spazio di indirizzi del processo. + \end{errlist}} +\end{prototype} + +La funzione è identica a \func{getsockname}, ed usa la stessa sintassi, ma +restituisce l'indirizzo remoto del socket, cioè quello associato all'altro +capo della connessione. Ci si può chiedere a cosa serva questa funzione dato +che dal lato client l'indirizzo remoto è sempre noto quando si esegue la +\func{connect} mentre dal lato server si possono usare, come vedremo in +\figref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di +\func{accept}. + +Il fatto è che in generale quest'ultimo caso non è sempre possibile. In +particolare questo avviene quando il server, invece di gestire la connessione +direttamente in un processo figlio, come vedremo nell'esempio di server +concorrente di \secref{sec:TCP_daytime_cunc_server}, lancia per ciascuna +connessione un altro programma, usando \func{exec}.\footnote{questa ad esempio + è la modalità con cui opera il \textsl{super-server} \cmd{inetd}, che può + gestire tutta una serie di servizi diversi, eseguendo su ogni connessione + ricevuta sulle porte tenute sotto controllo, il relativo server.} + +In questo caso benché il processo figlio abbia una immagine della memoria che +è copia di quella del processo padre (e contiene quindi anche la struttura +ritornata da \func{accept}), all'esecuzione di \func{exec} verrà caricata in +memoria l'immagine del programma eseguito, che a questo punto perde ogni +riferimento ai valori tornati da \func{accept}. Il socket descriptor però +resta aperto, e se si è seguita una opportuna convenzione per rendere noto al +programma eseguito qual'è il socket connesso, \footnote{ad esempio il solito + \cmd{inetd} fa sempre in modo che i file descriptor 0, 1 e 2 corrispondano + al socket connesso.} quest'ultimo potrà usare la funzione \func{getpeername} +per determinare l'indirizzo remoto del client. + +Infine è da chiarire (si legga la pagina di manuale) che, come per +\func{accept}, il terzo parametro, che è specificato dallo standard POSIX.1g +come di tipo \code{socklen\_t *} in realtà deve sempre corrispondere ad un +\ctyp{int *} come prima dello standard perché tutte le implementazioni dei +socket BSD fanno questa assunzione. + + +\subsection{La funzione \func{close}} +\label{sec:TCP_func_close} + +La funzione standard Unix \func{close} (vedi \secref{sec:file_close}) che si +usa sui file può essere usata con lo stesso effetto anche sui file descriptor +associati ad un socket. + +L'azione di questa funzione quando applicata a socket è di marcarlo come +chiuso e ritornare immediatamente al processo. Una volta chiamata il socket +descriptor non è più utilizzabile dal processo e non può essere usato come +argomento per una \func{write} o una \func{read} (anche se l'altro capo della +connessione non avesse chiuso la sua parte). Il kernel invierà comunque tutti +i dati che ha in coda prima di iniziare la sequenza di chiusura. + +Vedremo più avanti in \secref{sec:TCP_so_linger} come è possibile cambiare +questo comportamento, e cosa deve essere fatto perché il processo possa +assicurarsi che l'altro capo abbia ricevuto tutti i dati. + +Come per tutti i file descriptor anche per i socket viene mantenuto un numero +di riferimenti, per cui se più di un processo ha lo stesso socket aperto +l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata +fintanto che il numero di riferimenti non si annulla, questo si applica, come +visto in \secref{sec:file_sharing}, sia ai file descriptor duplicati che a +quelli ereditati dagli eventuali processi figli, ed è il comportamento che ci +si aspetta in una qualunque applicazione client/server. + +Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura +descritta in \secref{sec:TCP_conn_term}, si può invece usare la funzione +\func{shutdown} su cui torneremo in seguito (vedi \secref{sec:xxx_shutdown}). + + + +\section{Un esempio elementare: il servizio \textit{daytime}} +\label{sec:TCP_daytime_application} + +Avendo introdotto le funzioni di base per la gestione dei socket, potremo +vedere in questa sezione un primo esempio di applicazione elementare che +implementa il servizio \textit{daytime} su TCP, secondo quanto specificato +dall'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}. Prima di passare +agli esempi del client e del server, inizieremo riesaminando con maggiori +dettagli una peculiarità delle funzioni di I/O, già accennata in +\secref{sec:file_read} e \secref{sec:file_write}, che nel caso dei socket è +particolarmente rilevante. Passeremo poi ad illustrare gli esempi +dell'implementazione, sia dal lato client, che dal lato server, che si è +realizzato sia in forma iterativa che concorrente. + + +\subsection{Il comportamento delle funzioni di I/O} +\label{sec:sock_io_behav} + +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} +possano restituire in input o scrivere in output un numero di byte minore di +quello richiesto. Come già accennato in \secref{sec:file_read} questo è un +comportamento normale per l'I/O su file, ma con i normali file di dati il +problema si avverte solo quando si incontra la fine del file. In generale non +è così, e con i socket questo è particolarmente evidente. + + +\begin{figure}[htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \includecodesample{listati/FullRead.c} + \end{minipage} + \normalsize + \caption{La funzione \func{FullRead}, che legge esattamente \var{count} byte + da un file descriptor, iterando opportunamente le letture.} + \label{fig:sock_FullRead_code} +\end{figure} + +Quando ci si trova ad affrontare questo comportamento tutto quello che si deve +fare è semplicemente ripetere la lettura (o la scrittura) per la quantità di +byte restanti, tenendo conto che le funzioni si possono bloccare se i dati non +sono disponibili: è lo stesso comportamento che si può avere scrivendo più di +\const{PIPE\_BUF} byte in una pipe (si riveda quanto detto in +\secref{sec:ipc_pipes}). + +Per questo motivo, seguendo l'esempio di R. W. Stevens in \cite{UNP1}, si sono +definite due funzioni, \func{FullRead} e \func{FullWrite}, che eseguono +lettura e scrittura tenendo conto di questa caratteristica, ed in grado di +ritornare solo dopo avere letto o scritto esattamente il numero di byte +specificato; il sorgente è riportato rispettivamente in +\figref{fig:sock_FullRead_code} e \figref{fig:sock_FullWrite_code} ed è +disponibile fra i sorgenti allegati alla guida nei file \file{FullRead.c} e +\file{FullWrite.c}. + +\begin{figure}[htb] + \centering + \footnotesize \centering + \begin{minipage}[c]{15cm} + \includecodesample{listati/FullWrite.c} + \end{minipage} + \normalsize + \caption{La funzione \func{FullWrite}, che scrive esattamente \var{count} + byte su un file descriptor, iterando opportunamente le scritture.} + \label{fig:sock_FullWrite_code} +\end{figure} + +Come si può notare le due funzioni ripetono la lettura/scrittura in un ciclo +fino all'esaurimento del numero di byte richiesti, in caso di errore viene +controllato se questo è \errcode{EINTR} (cioè un'interruzione della system +call dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti +l'errore viene ritornato al programma chiamante, interrompendo il ciclo. + +Nel caso della lettura, se il numero di byte letti è zero, significa che si è +arrivati alla fine del file (per i socket questo significa in genere che +l'altro capo è stato chiuso, e quindi non sarà più possibile leggere niente) e +pertanto si ritorna senza aver concluso la lettura di tutti i byte richiesti. + + +\subsection{Il client \textit{daytime}} +\label{sec:TCP_daytime_client} + +Il primo esempio di applicazione delle funzioni di base illustrate in +precedenza è relativo alla creazione di un client elementare per il servizio +\textit{daytime}, un servizio elementare, definito +nell'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}, che restituisce +l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato +alla porta 13. + +In \figref{fig:TCP_daytime_client_code} è riportata la sezione principale del +codice del nostro client. Il sorgente completo del programma +(\file{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una +funzione per stampare un messaggio di aiuto) è allegato alla guida nella +sezione dei codici sorgente e può essere compilato su una qualunque macchina +GNU/Linux. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \includecodesample{listati/TCP_daytime.c} + \end{minipage} + \normalsize + \caption{Esempio di codice di un client elementare per il servizio + \textit{daytime}.} + \label{fig:TCP_daytime_client_code} +\end{figure} + +Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari; +dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa +tutta la parte relativa al trattamento degli argomenti passati dalla linea di +comando (effettuata con le apposite funzioni illustrate in +\secref{sec:proc_opt_handling}). + +Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo +\const{SOCK\_STREAM} e di famiglia \const{AF\_INET}). La funzione +\func{socket} ritorna il descrittore che viene usato per identificare il +socket in tutte le chiamate successive. Nel caso la chiamata fallisca si +stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce +(\texttt{\small 16}) con un codice di errore. + +Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita +struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed +il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è +inizializzare tutto a zero, per poi inserire il tipo di indirizzo +(\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima +la funzione \func{htons} per convertire il formato dell'intero usato dal +computer a quello usato nella rete, infine \texttt{\small 23--27} si può +utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico +passato dalla linea di comando. + +A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul +socket creato in precedenza (\texttt{\small 29}) si può stabilire la +connessione con il server. Per questo si deve utilizzare come secondo +argomento la struttura preparata in precedenza con il relativo indirizzo; si +noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast. +Un valore di ritorno della funzione negativo implica il fallimento della +connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si +ritorna (\texttt{\small 31}). + +Completata con successo la connessione il passo successivo (\texttt{\small + 34--40}) è leggere la data dal socket; il protocollo prevede che il server +invii sempre una stringa alfanumerica, il formato della stringa non è +specificato dallo standard, per cui noi useremo il formato usato dalla +funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè +qualcosa del tipo: +\begin{verbatim} +Wed Apr 4 00:53:00 2001\r\n +\end{verbatim} +questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read} +in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small + 35}) con il solito carattere nullo per poter essere stampata (\texttt{\small + 36}) sullo standard output con l'uso di \func{fputs}. + +Come si è già spiegato in \secref{sec:sock_io_behav} la risposta dal socket +potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel +caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte. Per +questo nel caso generale non si può mai assumere che tutti i dati arrivino con +una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo +in cui si continui a leggere fintanto che la funzione \func{read} non ritorni +uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero +minore di zero (che significa un errore nella connessione). + +Si noti come in questo caso la fine dei dati sia specificata dal server che +chiude la connessione (anche questo è quanto richiesto dal protocollo); questa +è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma +ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco +di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed), +mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il +punto essenziale è che TCP non provvede nessuna indicazione che permetta di +marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il +programma stesso. + +Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene + fornito direttamente dal \textsl{superdemone} \texttt{inetd}, pertanto basta + assicurarsi che esso sia abilitato nel relativo file di configurazione.} +possiamo verificare il funzionamento del nostro client, avremo allora: +\begin{verbatim} +[piccardi@gont sources]$ ./daytime 127.0.0.1 +Mon Apr 21 20:46:11 2003 +\end{verbatim}%$ +e come si vede tutto funziona regolarmente. + + +\subsection{Un server \textit{daytime} iterativo} +\label{sec:TCP_daytime_iter_server} + +Dopo aver illustrato il client daremo anche un esempio di un server +elementare, che sia anche in grado di rispondere al precedente client. Come +primo esempio realizzeremo un server iterativo, in grado di fornire una sola +risposta alla volta. Il codice del programma è nuovamente mostrato in +\figref{fig:TCP_daytime_iter_server_code}, il sorgente completo +(\file{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli esempi. + +\begin{figure}[!htbp] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \includecodesample{listati/TCP_iter_daytimed.c} + \end{minipage} + \normalsize + \caption{Esempio di codice di un semplice server per il servizio daytime.} + \label{fig:TCP_daytime_iter_server_code} +\end{figure} + +Come per il client si includono (\texttt{\small 1--9}) gli header necessari a +cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small + 14--18}) alcune costanti e le variabili necessarie in seguito. Come nel caso +precedente si sono omesse le parti relative al trattamento delle opzioni da +riga di comando. + +La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente, +come pure l'inizializzazione (\texttt{\small 25--29}) della struttura +\struct{sockaddr\_in}. Anche in questo caso (\texttt{\small 28}) si usa la +porta standard del servizio daytime, ma come indirizzo IP si usa +(\texttt{\small 27}) il valore predefinito \const{INET\_ANY}, che corrisponde +all'indirizzo generico. + +Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind} +che permette di associare la precedente struttura al socket, in modo che +quest'ultimo possa essere usato per accettare connessioni su una qualunque +delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small + 31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il +programma. + +Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``in +ascolto'' il socket; questo viene fatto (\texttt{\small 36}) con la funzione +\func{listen} che dice al kernel di accettare connessioni per il socket che +abbiamo creato; la funzione indica inoltre, con il secondo parametro, il +numero massimo di connessioni che il kernel accetterà di mettere in coda per +il suddetto socket. Di nuovo in caso di errore si stampa (\texttt{\small 37}) +un messaggio, e si esce (\texttt{\small 38}) immediatamente. + +La chiamata a \func{listen} completa la preparazione del socket per l'ascolto +(che viene chiamato anche \textit{listening descriptor}) a questo punto si può +procedere con il ciclo principale (\texttt{\small 40--53}) che viene eseguito +indefinitamente. Il primo passo (\texttt{\small 42}) è porsi in attesa di +connessioni con la chiamata alla funzione \func{accept}, come in precedenza in +caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce +(\texttt{\small 44}). + +Il processo resterà in stato di \textit{sleep} fin quando non arriva e viene +accettata una connessione da un client; quando questo avviene \func{accept} +ritorna, restituendo un secondo descrittore, che viene chiamato +\textit{connected descriptor}, e che è quello che verrà usato dalla successiva +chiamata alla \func{write} per scrivere la risposta al client. + +Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente +con una chiamata a \texttt{time}, con il quale si potrà opportunamente +costruire (\texttt{\small 47}) la stringa con la data da trasmettere +(\texttt{\small 48}) con la chiamata a \func{write}. Completata la +trasmissione il nuovo socket viene chiuso (\texttt{\small 52}). A questo +punto il ciclo si chiude ricominciando da capo in modo da poter ripetere +l'invio della data in risposta ad una successiva connessione. + +È importante notare che questo server è estremamente elementare, infatti, a +parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado +di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un +\textsl{server iterativo}. Inoltre è scritto per essere lanciato da linea di +comando, se lo si volesse utilizzare come demone occorrerebbero le opportune +modifiche\footnote{come una chiamata a \func{daemon} prima dell'inizio del + ciclo principale.} per tener conto di quanto illustrato in +\secref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma di +gestione della terminazione del processo, dato che tutti i file descriptor +vengono chiusi automaticamente alla sua uscita, e che, non generando figli, +non è necessario preoccuparsi di gestire la loro terminazione. + + +\subsection{Un server \textit{daytime} concorrente} +\label{sec:TCP_daytime_cunc_server} + +Il server \texttt{daytime} dell'esempio in +\secref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo, +in cui viene servita una richiesta alla volta; in generale però, specie se il +servizio è più complesso e comporta uno scambio di dati più sostanzioso di +quello in questione, non è opportuno bloccare un server nel servizio di un +client per volta; per questo si ricorre alle capacità di multitasking del +sistema. + +Come accennato anche in \secref{sec:proc_gen} una delle modalità più comuni di +funzionamento da parte dei server è quella di usare la funzione \func{fork} +per creare, ad ogni richiesta da parte di un client, un processo figlio che si +incarichi della gestione della comunicazione. Si è allora riscritto il server +\textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche +una opzione per la stampa degli indirizzi delle connessioni ricevute. + +In \figref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del +codice, in cui si sono tralasciati il trattamento delle opzioni e le parti +rimaste invariate rispetto al precedente esempio (cioè tutta la parte +riguardante l'apertura passiva del socket). Al solito il sorgente completo del +server, nel file \file{TCP\_cunc\_daytimed.c}, è allegato insieme ai sorgenti +degli altri esempi. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15cm} + \includecodesample{listati/TCP_cunc_daytimed.c} + \end{minipage} + \normalsize + \caption{Esempio di codice di un server concorrente elementare per il + servizio daytime.} + \label{fig:TCP_daytime_cunc_server_code} +\end{figure} + +Stavolta (\texttt{\small 21--25}) la funzione \func{accept} è chiamata +fornendo una struttura di indirizzi in cui saranno ritornati l'indirizzo IP e +la porta da cui il client effettua la connessione, che in un secondo tempo, +(\texttt{\small 39--43}), se il logging è abilitato, stamperemo sullo standard +output. + +Quando \func{accept} ritorna il server chiama la funzione \func{fork} +(\texttt{\small 26--30}) per creare il processo figlio che effettuerà +(\texttt{\small 31--45}) tutte le operazioni relative a quella connessione, +mentre il padre proseguirà l'esecuzione del ciclo principale in attesa di +ulteriori connessioni. + +Si noti come il figlio operi solo sul socket connesso, chiudendo +immediatamente (\texttt{\small 32}) il socket \var{list\_fd}; mentre il padre +continua ad operare solo sul socket in ascolto chiudendo (\texttt{\small 47}) +\var{sock\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in +\secref{sec:TCP_func_close} nessuna delle due chiamate a \func{close} causa +l'innesco della sequenza di chiusura perché il numero di riferimenti al file +descriptor non si è annullato. + +Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e +lo stesso vale per \var{sock\_fd} dopo il ritorno di \func{accept}, ma dopo la +\func{fork} i descrittori vengono duplicati nel padre e nel figlio per cui +entrambi i socket si trovano con due referenze. Questo fa si che quando il +padre chiude \var{sock\_fd} esso resta con una referenza da parte del figlio, +e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato +le sue operazioni, chiamerà (\texttt{\small 44}) la funzione \func{close}. + +In realtà per il figlio non sarebbe necessaria nessuna chiamata a +\func{close}, in quanto con la \func{exit} finale (\texttt{\small 45}) tutti i +file descriptor, quindi anche quelli associati ai socket, vengono +automaticamente chiusi. Tuttavia si è preferito effettuare esplicitamente le +chiusure per avere una maggiore chiarezza del codice, e per evitare eventuali +errori, prevenendo ad esempio un uso involontario del \textit{listening + descriptor}. + +Si noti invece come sia essenziale che il padre chiuda ogni volta il socket +connesso dopo la \func{fork}; se così non fosse nessuno di questi socket +sarebbe effettivamente chiuso dato che alla chiusura da parte del figlio +resterebbe ancora un riferimento nel padre. Si avrebbero così due effetti: il +padre potrebbe esaurire i descrittori disponibili (che sono un numero limitato +per ogni processo) e soprattutto nessuna delle connessioni con i client +verrebbe chiusa. + +Come per ogni server iterativo il lavoro di risposta viene eseguito +interamente dal processo figlio. Questo si incarica (\texttt{\small 33}) di +chiamare \func{time} per leggere il tempo corrente, e di stamparlo +(\texttt{\small 34}) sulla stringa contenuta in \var{buffer} con l'uso di +\func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small + 35--38}) sul socket, controllando che non ci siano errori. Anche in questo +caso si è evitato il ricorso a \func{FullWrite} in quanto la stringa è +estremamente breve e verrà senz'altro scritta in un singolo segmento. + +Inoltre nel caso sia stato abilitato il \textit{logging} delle connessioni, si +provvede anche (\texttt{\small 39--42}) a stampare sullo standard output +l'indirizzo e la porta da cui il client ha effettuato la connessione, usando +i valori contenuti nelle strutture restituite da \func{accept}, eseguendo le +opportune conversioni con \func{inet\_ntop} e \func{atohs}. + +Ancora una volta l'esempio è estremamente semplificato, si noti come di nuovo +non si sia gestita né la terminazione del processo né il suo uso come demone, +che tra l'altro sarebbe stato incompatibile con l'uso della opzione di logging +che stampa gli indirizzi delle connessioni sullo standard output. Un altro +aspetto tralasciato è la gestione della terminazione dei processi figli, +torneremo su questo più avanti quando tratteremo alcuni esempi di server più +complessi. + + + +\section{Un esempio più completo: il servizio \textit{echo}} +\label{sec:TCP_echo_application} + +L'esempio precedente, basato sul servizio \textit{daytime}, è un esempio molto +elementare, in cui il flusso dei dati va solo nella direzione dal server al +client. In questa sezione esamineremo un esempio di applicazione client/server +un po' più complessa, che usi i socket TCP per una comunicazione in entrambe +le direzioni, implementando il servizio standard \textit{echo}, così come +definito dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}. + +Si è scelto, seguendo l'esempio di \cite{UNP1}, di usare questo servizio, che +si limita a restituire in uscita quanto immesso in ingresso, perché nonostante +la sua estrema semplicità costituisce il prototipo ideale di una generica +applicazione di rete in cui un server risponde alle richieste di un client; +nel caso di una applicazione più complessa si potrà avere in più una +elaborazione dell'input del client da parte del server nel fornire le risposte +in uscita. + +Ci limiteremo per ora ad una implementazione elementare, che usi solo le +funzioni di base, ma prenderemo in esame, oltre al comportamento in condizioni +normali, anche tutti i possibili scenari particolari (errori, sconnessione +della rete, crash del client o del server durante la connessione) che possono +avere luogo durante l'impiego di un'applicazione di rete, partendo da una +versione primitiva che dovrà essere rimaneggiata di volta in volta per poter +tenere conto di tutte le evenienze che si possono manifestare nella vita reale +di un'applicazione di rete, fino ad arrivare ad un'implementazione completa. + + +\subsection{Il client: prima versione} +\label{sec:TCP_echo_client} + +Il codice della prima versione client per il servizio \textit{echo} è +riportato in \figref{fig:TCP_echo_client_1}. Esso ricalca la struttura del +precedente client per il servizio \textit{daytime} (vedi +\secref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27}) è +sostanzialmente identica, a parte l'uso di una porta diversa. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6 cm} + \includecodesample{listati/TCP_echo_client.c} + \end{minipage} + \normalsize + \caption{Codice della prima versione del client \textit{echo}.} + \label{fig:TCP_echo_client_1} +\end{figure} + +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, la preparazione +(\texttt{\small 14--17}) la struttura per l'indirizzo, con la relativa +conversione (\texttt{\small 18--22}) di quanto specificato a riga di comando. + +A questo punto (\texttt{\small 23--27}) si può eseguire la connessione al +server secondo la stessa modalità usata in \secref{sec:TCP_daytime_client}. +Completata la connessione, al ritorno di \func{connect}, si usa la funzione +\code{ClientEcho}, il cui codice è riportato in +\figref{fig:TCPsimpl_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. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6cm} + \includecodesample{listati/ClientEcho.c} + \end{minipage} + \normalsize + \caption{Codice della prima versione della funzione \texttt{ClientEcho} per + la gestione del servizio \textit{echo}.} + \label{fig:TCPsimpl_client_echo_sub} +\end{figure} + +La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per +gestire i dati inviati e letti sul socket. La comunicazione viene gestita +all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla +connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets}, +trattata in \secref{sec:file_line_io}, che legge una linea di testo (terminata +da un \texttt{CR} e fino al massimo di \const{MAXLINE} caratteri) e la salva +sul buffer di invio, la funzione \func{FullWrite}, già vista in +\figref{fig:sock_FullWrite_code}, scrive (\texttt{\small 6}) i dati sul socket +(gestendo l'invio multiplo qualora una singola \func{write} non basti, come +spiegato in \secref{sec:sock_io_behav}). + +I dati vengono riletti indietro (\texttt{\small 7}) con una \func{FullRead} +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}. + +Un end-of-file inviato su \file{stdin} (ad esempio con la pressione di +\texttt{C-d}) causa il ritorno di \func{fgets} con un puntatore nullo e la +conseguente uscita dal ciclo, al che la subroutine ritorna ed il client esce. + + +\subsection{Il server: prima versione} +\label{sec:TCPsimp_server_main} + +Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti +direttamente dal superserver \cmd{inetd}, ed è definito +dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}. Come dice il nome il +servizio deve rimandare indietro sulla connessione i dati che gli vengono +inviati; l'RFC descrive le specifiche sia per TCP che UDP, e per il primo +stabilisce che una volta stabilita la connessione ogni dato in ingresso deve +essere rimandato in uscita, fintanto che il chiamante non ha chiude la +connessione; il servizio opera sulla porta 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, il server leggerà la +linea dalla connessione e la riscriverà all'indietro; sarà compito del client +leggere la risposta del server e stamparla sullo standard output. + +La prima versione del server, \file{ElemEchoTCPServer.c}, si compone di un +corpo principale, costituito dalla funzione \code{main}. Questa si incarica +di creare il socket, metterlo in ascolto di connessioni in arrivo e creare un +processo figlio a cui delegare la gestione di ciascuna connessione. Questa +parte, riportata in \figref{fig:TCPsimpl_serv_code}, è analoga a quella vista +nel precedente esempio esaminato in \secref{sec:TCP_daytime_cunc_server}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6cm} + \includecodesample{listati/ElemEchoTCPServer.c} + \end{minipage} + \normalsize + \caption{Codice della funzione \code{main} della prima versione del server + per il servizio \textit{echo}.} + \label{fig:TCPsimpl_serv_code} +\end{figure} + +La struttura di questa prima versione del server è sostanzialmente identica a +quella dell'esempio citato, ed ad esso si applicano le considerazioni fatte in +\secref{sec:TCP_daytime_cunc_server}. Le uniche differenze rispetto +all'esempio in \figref{fig:TCP_daytime_cunc_server_code} sono che in questo +caso per il socket in ascolto viene usata la porta 7 e che tutta la gestione +della comunicazione è delegata alla funzione \code{ServEcho}. +% Per ogni connessione viene creato un +% processo figlio, il quale si incarica di lanciare la funzione +% \texttt{SockEcho}. + +Il codice della funzione \code{ServEcho} è invece mostrata in +\figref{fig:TCPsimpl_server_elem_sub}, la comunicazione viene gestita +all'interno del ciclo (linee \texttt{\small 6--8}). I dati inviati dal client +vengono letti dal socket con una semplice \func{read} (che ritorna solo in +presenza di dati in arrivo), la riscrittura viene invece gestita dalla +funzione \func{FullWrite} (descritta in \figref{fig:sock_FullWrite_code}) che +si incarica di tenere conto automaticamente della possibilità che non tutti i +dati di cui è richiesta la scrittura vengano trasmessi con una singola +\func{write}. + +\begin{figure}[!htb] + \footnotesize \centering + \begin{minipage}[c]{15.6cm} + \includecodesample{listati/ServEcho.c} + \end{minipage} + \normalsize + \caption{Codice della prima versione della funzione \code{ServEcho} per la + gestione del servizio \textit{echo}.} + \label{fig:TCPsimpl_server_elem_sub} +\end{figure} + +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 della funzione, che a sua volta causa la terminazione +del processo figlio. + + + + +\subsection{L'avvio e il funzionamento normale} +\label{sec:TCPsimpl_startup} + +Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà +di considerare in dettaglio tutte le problematiche che si possono incontrare +nello scrivere un'applicazione di rete. Infatti attraverso l'esame delle sue +modalità di funzionamento normali, all'avvio e alla terminazione, e di quello +che avviene nelle varie situazioni limite, da una parte potremo approfondire +la comprensione del protocollo TCP/IP e dall'altra ricavare le indicazioni +necessarie per essere in grado di scrivere applicazioni robuste, in grado di +gestire anche i casi limite. + +Il primo passo è compilare e lanciare il server (da root, per poter usare la +porta 7 che è riservata), alla partenza esso eseguirà l'apertura passiva con +la sequenza delle chiamate a \func{socket}, \func{bind}, \func{listen} e poi +si bloccherà nella \func{accept}. A questo punto si potrà controllarne lo +stato con \cmd{netstat}: +\begin{verbatim} +[piccardi@roke piccardi]$ netstat -at +Active Internet connections (servers and established) +Proto Recv-Q Send-Q Local Address Foreign Address State +... +tcp 0 0 *:echo *:* LISTEN +... +\end{verbatim} %$ +che ci mostra come il socket sia in ascolto sulla porta richiesta, accettando +connessioni da qualunque indirizzo e da qualunque porta e su qualunque +interfaccia locale. + +A questo punto si può lanciare il client, esso chiamerà \func{socket} e +\func{connect}; una volta completato il three way handshake la connessione è +stabilita; la \func{connect} ritornerà nel client\footnote{si noti che è + sempre la \func{connect} del client a ritornare per prima, in quanto + questo avviene alla ricezione del secondo segmento (l'ACK del server) del + three way handshake, la \func{accept} del server ritorna solo dopo + un altro mezzo RTT quando il terzo segmento (l'ACK del client) viene + ricevuto.} e la \func{accept} nel server, ed usando di nuovo +\cmd{netstat} otterremmo che: +\begin{verbatim} +Active Internet connections (servers and established) +Proto Recv-Q Send-Q Local Address Foreign Address State +tcp 0 0 *:echo *:* LISTEN +tcp 0 0 roke:echo gont:32981 ESTABLISHED +\end{verbatim} +mentre per quanto riguarda l'esecuzione dei programmi avremo che: +\begin{itemize} +\item il client chiama la funzione \code{ClientEcho} che si blocca sulla + \func{fgets} dato che non si è ancora scritto nulla sul terminale. +\item il server eseguirà una \func{fork} facendo chiamare al processo figlio + la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read} + dal socket sul quale ancora non sono presenti dati. +\item il processo padre del server chiamerà di nuovo \func{accept} + bloccandosi fino all'arrivo di un'altra connessione. +\end{itemize} +e se usiamo il comando \cmd{ps} per esaminare lo stato dei processi otterremo +un risultato del tipo: +\begin{verbatim} +[piccardi@roke piccardi]$ ps ax + PID TTY STAT TIME COMMAND + ... ... ... ... ... + 2356 pts/0 S 0:00 ./echod + 2358 pts/1 S 0:00 ./echo 127.0.0.1 + 2359 pts/0 S 0:00 ./echod +\end{verbatim} %$ +(dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di +tre processi, tutti in stato di \textit{sleep} (vedi +\tabref{tab:proc_proc_states}). + +Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso +niente fin tanto che non si prema il tasto di a capo (si ricordi quanto detto +in \secref{sec:file_line_io} a proposito dell'I/O su terminale), solo allora +\func{fgets} ritornerà ed il client scriverà quanto immesso sul socket, per +poi passare a rileggere quanto gli viene inviato all'indietro dal server, che +a sua volta sarà inviato sullo standard output, che nel caso ne provoca +l'immediatamente stampa a video. + + +\subsection{La conclusione normale} +\label{sec:TCPsimpl_conclusion} + +Tutto quello che scriveremo sul client sarà rimandato indietro dal server e +ristampato a video fintanto che non concluderemo l'immissione dei dati; una +sessione tipica sarà allora del tipo: +\begin{verbatim} +[piccardi@roke sources]$ ./echo 127.0.0.1 +Questa e` una prova +Questa e` una prova +Ho finito +Ho finito +\end{verbatim} %$ +che termineremo inviando un EOF dal terminale (usando la combinazione di tasti +ctrl-D, che non compare a schermo); se eseguiamo un \cmd{netstat} a questo +punto avremo: +\begin{verbatim} +[piccardi@roke piccardi]$ netstat -at +tcp 0 0 *:echo *:* LISTEN +tcp 0 0 localhost:33032 localhost:echo TIME_WAIT +\end{verbatim} %$ +con il client che entra in \texttt{TIME\_WAIT}. + +Esaminiamo allora in dettaglio la sequenza di eventi che porta alla +terminazione normale della connessione, che ci servirà poi da riferimento +quando affronteremo il comportamento in caso di conclusioni anomale: + +\begin{enumerate} +\item inviando un carattere di EOF da terminale la \func{fgets} ritorna + restituendo un puntatore nullo che causa l'uscita dal ciclo di + \code{while}, così la \code{ClientEcho} ritorna. +\item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e + come parte del processo terminazione tutti i file descriptor vengono chiusi + (si ricordi quanto detto in \secref{sec:proc_term_conclusion}); questo causa + la chiusura del socket di comunicazione; il client allora invierà un FIN al + server a cui questo risponderà con un ACK. A questo punto il client verrà a + trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato + \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in + \secref{sec:TCP_conn_term}). +\item quando il server riceve il FIN la \func{read} del processo figlio che + gestisce la connessione ritorna restituendo 0 causando così l'uscita dal + ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio + termina chiamando \func{exit}. +\item all'uscita del figlio tutti i file descriptor vengono chiusi, la + chiusura del socket connesso fa sì che venga effettuata la sequenza finale + di chiusura della connessione, viene emesso un FIN dal server che riceverà + un ACK dal client, a questo punto la connessione è conclusa e il client + resta nello stato \texttt{TIME\_WAIT}. + +\end{enumerate} + -\subsection{La funzione \texttt{listen}} -\label{sec:TCPel_func_listen} +\subsection{La gestione dei processi figli} +\label{sec:TCPsimpl_child_hand} -\subsection{La funzione \texttt{accept}} -\label{sec:TCPel_func_accept} +Tutto questo riguarda la connessione, c'è però da tenere conto dell'effetto +del procedimento di chiusura del processo figlio nel server (si veda quanto +esaminato in \secref{sec:proc_termination}). In questo caso avremo l'invio del +segnale \const{SIGCHLD} al padre, ma dato che non si è installato un +gestore e che l'azione predefinita per questo segnale è quella di essere +ignorato, non avendo predisposto la ricezione dello stato di terminazione, +otterremo che il processo figlio entrerà nello stato di zombie\index{zombie} +(si riveda quanto illustrato in \secref{sec:sig_sigchld}), come risulterà +ripetendo il comando \cmd{ps}: +\begin{verbatim} + 2356 pts/0 S 0:00 ./echod + 2359 pts/0 Z 0:00 [echod ] +\end{verbatim} +Poiché non è possibile lasciare processi zombie\index{zombie} che pur inattivi +occupano spazio nella tabella dei processi e a lungo andare saturerebbero le +risorse del kernel, occorrerà ricevere opportunamente lo stato di terminazione +del processo (si veda \secref{sec:proc_wait}), cosa che faremo utilizzando +\const{SIGCHLD} secondo quanto illustrato in \secref{sec:sig_sigchld}. -\subsection{Le porte} +La 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}, illustrata in +\figref{fig:sig_Signal_code}, per installare il semplice gestore che +riceve i segnali dei processi figli terminati già visto in +\figref{fig:sig_sigchld_handl}; aggiungendo il seguente codice: +\includecodesnip{listati/sigchildhand.c} +\noindent +all'esempio illustrato in \figref{fig:TCPsimpl_serv_code}, e linkando il tutto +alla funzione \code{sigchld\_hand}, si risolverà completamente il problema +degli zombie\index{zombie}. +%%% Local Variables: +%%% mode: latex +%%% TeX-master: "gapil" +%%% End: