X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=elemtcp.tex;fp=elemtcp.tex;h=0000000000000000000000000000000000000000;hp=a49c48c5d0dbd8a5354cbc1cd7512eb3b3f2ecd8;hb=24b55de696cfd8c0d7238a6b536802aba233912d;hpb=571305d265d04aec0e35182ff17197043757e14a diff --git a/elemtcp.tex b/elemtcp.tex deleted file mode 100644 index a49c48c..0000000 --- a/elemtcp.tex +++ /dev/null @@ -1,2262 +0,0 @@ -%% elemtcp.tex -%% -%% Copyright (C) 2000-2003 Simone Piccardi. Permission is granted to -%% copy, distribute and/or modify this document under the terms of the GNU Free -%% Documentation License, Version 1.1 or any later version published by the -%% Free Software Foundation; with the Invariant Sections being "Prefazione", -%% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the -%% license is included in the section entitled "GNU Free Documentation -%% License". -%% -\chapter{Socket TCP} -\label{cha:TCP_socket} - -In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP, -iniziando con una descrizione delle principali caratteristiche del -funzionamento di una connessione TCP. Tratteremo poi le varie funzioni che -servono alla creazione di una connessione fra un server elementare ed il suo -client, fornendo poi alcuni esempi di applicazione elementare. - - - -\section{Il funzionamento di una connessione TCP} -\label{sec:TCP_connession} - -Prima di entrare nei dettagli delle singole funzioni usate nelle applicazioni -che utilizzano i socket TCP, è fondamentale spiegare alcune delle basi del -funzionamento del protocollo, poiché questa conoscenza è essenziale per -comprendere il comportamento di dette funzioni per questo tipo di socket, ed -il relativo modello di programmazione. - -Si ricordi che il protocollo TCP serve a creare degli \textit{stream socket}, -cioè una forma di canale di comunicazione che stabilisce una connessione -stabile fra due stazioni, in modo che queste possano scambiarsi dei dati. In -questa sezione ci concentreremo sulle modalità con le quali il protocollo dà -inizio e conclude una connessione e faremo inoltre un breve accenno al -significato di alcuni dei vari \textsl{stati} ad essa associati. - -\subsection{La creazione della connessione: il \textit{three way handshake}} -\label{sec:TCP_conn_cre} - -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 (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 - \func{connect}, attraverso un procedimento che viene chiamato - \textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di - \func{connect} blocca il processo e causa l'invio da parte del client di un - segmento SYN, in sostanza viene inviato al server un pacchetto IP che - contiene solo gli header IP e TCP (con il numero di sequenza iniziale e il - flag SYN) e le opzioni di TCP. - -\item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del - client, inoltre anche il server deve inviare il suo SYN al client (e - trasmettere il suo numero di sequenza iniziale) questo viene fatto - ritrasmettendo un singolo segmento in cui sono impostati entrambi i flag SYN - e ACK. - -\item una volta che il client ha ricevuto l'acknowledge dal server la funzione - \func{connect} ritorna, l'ultimo passo è dare dare il ricevuto del SYN del - 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 -% sistema del telefono. La funzione \texttt{socket} può essere considerata -% l'equivalente di avere un telefono. La funzione \texttt{bind} è analoga al -% dire alle altre persone qual'è il proprio numero di telefono perché possano -% chiamare. La funzione \texttt{listen} è accendere il campanello del telefono -% per sentire le chiamate in arrivo. La funzione \texttt{connect} richiede di -% conoscere il numero di chi si vuole chiamare. La funzione \texttt{accept} è -% quando si risponde al telefono. - -\begin{figure}[htb] - \centering - \includegraphics[width=10cm]{img/three_way_handshake} - \caption{Il \textit{three way handshake} del TCP.} - \label{fig:TCP_TWH} -\end{figure} - -Si è accennato in precedenza ai \textsl{numeri di sequenza} (che sono anche -riportati in \figref{fig:TCP_TWH}): per gestire una connessione affidabile -infatti il protocollo TCP prevede nell'header la presenza di un numero a 32 -bit (chiamato appunto \textit{sequence number}) che identifica a quale byte -nella sequenza del flusso corrisponde il primo byte della sezione dati -contenuta nel segmento. - -Il numero di sequenza di ciascun segmento viene calcolato a partire da un -\textsl{numero di sequenza iniziale} generato in maniera casuale del kernel -all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di -ciascun segmento viene effettuato dall'altro capo della connessione 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 \figref{fig:TCP_close}) per l'acknowledgement di un FIN. - -\subsection{Le opzioni TCP.} -\label{sec:TCP_TCP_opt} - -Ciascun segmento SYN contiene in genere delle opzioni per il protocollo TCP -(le cosiddette \textit{TCP options}, che vengono inserite fra l'header e i -dati) che servono a comunicare all'altro capo una serie di parametri utili a -regolare la connessione. Normalmente vengono usate le seguenti opzioni: - -\begin{itemize} -\item \textit{MSS option}, dove MMS sta per \textit{maximum segment size}, con - questa opzione ciascun capo della connessione annuncia all'altro il massimo - ammontare di dati che vorrebbe accettare per ciascun segmento nella - connessione corrente. È possibile leggere e scrivere questo valore - attraverso l'opzione del socket \const{TCP\_MAXSEG}. - -\item \textit{window scale option}, %come spiegato in \secref{sec:tcp_protocol} - il protocollo TCP implementa il controllo di flusso attraverso una - \textsl{finestra annunciata} (\textit{advertized window}) con la quale - ciascun capo della comunicazione dichiara quanto spazio disponibile ha in - memoria per i dati. Questo è un numero a 16 bit dell'header, che così può - indicare un massimo di 65535 byte;\footnote{ Linux usa come massimo 32767 - per evitare problemi con alcune implementazioni che usano l'aritmetica con - segno per implementare lo stack TCP.} ma alcuni tipi di connessione come - quelle ad alta velocità (sopra i 45Mbit/sec) e quelle che hanno grandi - ritardi nel cammino dei pacchetti (come i satelliti) richiedono una finestra - più grande per poter ottenere il massimo dalla trasmissione, per questo - esiste questa opzione che indica un fattore di scala da applicare al valore - della finestra annunciata\footnote{essendo una nuova opzione per garantire - la compatibilità con delle vecchie implementazioni del protocollo la - procedura che la attiva prevede come negoziazione che l'altro capo della - connessione riconosca esplicitamente l'opzione inserendola anche lui nel - suo SYN di risposta dell'apertura della connessione.} per la connessione - corrente (espresso come numero di bit cui spostare a sinistra il valore - della finestra annunciata inserito nel pacchetto). - -\item \textit{timestamp option}, è anche questa una nuova opzione necessaria - per le connessioni ad alta velocità per evitare possibili corruzioni di dati - dovute a pacchetti perduti che riappaiono; anche questa viene negoziata come - la precedente. - -\end{itemize} - -La MSS è generalmente supportata da quasi tutte le implementazioni del -protocollo, le ultime due opzioni (trattate -nell'\href{http://www.ietf.org/rfc/rfc1323.txt}{RFC~1323}) sono meno comuni; -vengono anche dette \textit{long fat pipe options} dato che questo è il nome -che viene dato alle connessioni caratterizzate da alta velocità o da ritardi -elevati. In ogni caso Linux supporta pienamente entrambe le opzioni. - -\subsection{La terminazione della connessione} -\label{sec:TCP_conn_term} - -Mentre per la creazione di una connessione occorre un interscambio di tre -segmenti, la procedura di chiusura ne richiede normalmente quattro. In questo -caso la successione degli eventi è la seguente: - -\begin{enumerate} -\item Un processo ad uno dei due capi chiama la funzione \func{close}, dando - l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o - \textit{active close}). Questo comporta l'emissione di un segmento FIN, che - serve ad indicare che si è finito con l'invio dei dati sulla connessione. - -\item L'altro capo della connessione riceve il FIN e dovrà eseguire la - \textsl{chiusura passiva} (o \textit{passive close}). Al FIN, come ad ogni - altro pacchetto, viene risposto con un ACK, inoltre il ricevimento del FIN - viene segnalato al processo che ha aperto il socket (dopo che ogni altro - eventuale dato rimasto in coda è stato ricevuto) come un end-of-file sulla - lettura: questo perché il ricevimento di un FIN significa che non si - riceveranno altri dati sulla connessione. - -\item Una volta rilevata l'end-of-file anche il secondo processo chiamerà la - funzione \func{close} sul proprio socket, causando l'emissione di un altro - segmento FIN. - -\item L'altro capo della connessione riceverà il FIN conclusivo e risponderà - con un ACK. -\end{enumerate} - -Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione -normalmente i segmenti scambiati sono quattro. Questo non è vero sempre -giacché in alcune situazioni il FIN del passo 1) è inviato insieme a dei dati. -Inoltre è possibile che i segmenti inviati nei passi 2 e 3 dal capo che -effettua la chiusura passiva, siano accorpati in un singolo segmento. In -\figref{fig:TCP_close} si è rappresentato graficamente lo sequenza di -scambio dei segmenti che conclude la connessione. - -\begin{figure}[htb] - \centering - \includegraphics[width=10cm]{img/tcp_close} - \caption{La chiusura di una connessione TCP.} - \label{fig:TCP_close} -\end{figure} - -Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui -l'ACK riporterà un \textit{acknowledge number} incrementato di uno. - -Si noti che, nella sequenza di chiusura, fra i passi 2 e 3, è in teoria -possibile che si mantenga un flusso di dati dal capo della connessione che -deve ancora eseguire la chiusura passiva a quello che sta eseguendo la -chiusura attiva. Nella sequenza indicata i dati verrebbero persi, dato che si -è chiuso il socket dal lato che esegue la chiusura attiva; esistono tuttavia -situazioni in cui si vuole poter 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 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:TCP_echo}) sia stato il client ad eseguire -la chiusura attiva, nella realtà questa può essere eseguita da uno qualunque -dei due capi della comunicazione (come nell'esempio di -\figref{fig:TCP_daytime_iter_server_code}), e anche se il caso più comune -resta quello del client, ci sono alcuni servizi, il principale dei quali è -l'HTTP, per i quali è il server ad effettuare la chiusura attiva. - - -\subsection{Un esempio di connessione} -\label{sec:TCP_conn_dia} - -Come abbiamo visto le operazioni del TCP nella creazione e conclusione di una -connessione sono piuttosto complesse, ed abbiamo esaminato soltanto quelle -relative ad un andamento normale. In \secref{sec:TCP_states} vedremo con -maggiori dettagli che una connessione può assumere vari stati, che ne -caratterizzano il funzionamento, e che sono quelli che vengono riportati dal -comando \cmd{netstat}, per ciascun socket TCP aperto, nel campo -\textit{State}. - -Non possiamo affrontare qui una descrizione completa del funzionamento del -protocollo; un approfondimento sugli aspetti principali si trova in -\secref{sec:tcp_protocol}, ma per una trattazione completa il miglior -riferimento resta \cite{TCPIll1}. Qui ci limiteremo a descrivere brevemente un -semplice esempio di connessione e le transizioni che avvengono nei due casi -appena citati (creazione e terminazione della connessione). - -In assenza di connessione lo stato del TCP è \texttt{CLOSED}; quando una -applicazione esegue una apertura attiva il TCP emette un SYN e lo stato -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: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 un socket deve rimanere attivo nello stato \texttt{TIME\_WAIT} anche -dopo l'invio dell'ultimo ACK, per potere essere in grado di gestirne -l'eventuale ritrasmissione, in caso esso venga perduto. - -Il secondo motivo è più complesso da capire, e necessita di una spiegazione -degli scenari in cui può accadere che i pacchetti TCP si possano perdere nella -rete o restare intrappolati, per poi riemergere in un secondo tempo. - -Il caso più comune in cui questo avviene è quello di anomalie -nell'instradamento; può accadere cioè che un router smetta di funzionare o che -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 (affronteremo il significato delle porte -nella prossima sezione), che questa venga chiusa e che poco dopo si -ristabilisca la stessa connessione fra gli stessi IP sulle stesse porte -(quella che viene detta, essendo gli stessi porte e numeri IP, una nuova -\textsl{incarnazione} della connessione precedente); in questo caso ci si -potrebbe trovare con dei pacchetti duplicati relativi alla precedente -connessione che riappaiono nella nuova. - -Ma fintanto che il socket non è chiuso una nuova incarnazione non può essere -creata: per questo un socket TCP resta sempre nello stato \texttt{TIME\_WAIT} -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 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 aggiornata si può trovare all'indirizzo -\texttt{ftp://ftp.isi.edu/in-notes/iana/assignements/port-numbers}); inoltre -in un sistema unix-like un analogo elenco viene mantenuto nel file -\file{/etc/services}, con la corrispondenza fra i vari numeri di porta ed il -nome simbolico del servizio. I numeri sono divisi in tre intervalli: - -\begin{enumerate} -\item \textsl{le porte conosciute}. I numeri da 0 a 1023. Queste sono - controllate e assegnate dalla IANA. Se è possibile la stessa porta è - assegnata allo stesso servizio sia su UDP che su TCP (ad esempio la porta 22 - è assegnata a SSH su entrambi i protocolli, anche se viene usata solo dal - 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 amministratore, per far si che -solo l'amministratore possa allocare queste porte per far partire i relativi -servizi. - -Si tenga conto poi che ci sono alcuni client, in particolare \cmd{rsh} e -\cmd{rlogin}, che richiedono una connessione su una porta riservata anche dal -lato client come parte dell'autenticazione, contando appunto sul fatto che -solo l'amministratore può usare queste porte. Data l'assoluta inconsistenza in -termini di sicurezza di un tale metodo, al giorno d'oggi esso è in completo -disuso. - -Data una connessione TCP si suole chiamare \textit{socket pair}\footnote{da - non confondere con la coppia di socket della omonima funzione - \func{socketpair} che fanno riferimento ad una coppia di socket sulla stessa - macchina, non ai capi di una connessione TCP.} la combinazione dei quattro -numeri che definiscono i due capi della connessione e cioè l'indirizzo IP -locale e la porta TCP locale, e l'indirizzo IP remoto e la porta TCP remota. -Questa combinazione, che scriveremo usando una notazione del tipo -(\texttt{195.110.112.152:22}, \texttt{192.84.146.100:20100}), identifica -univocamente una connessione su internet. Questo concetto viene di solito -esteso anche a UDP, benché in questo caso non abbia senso parlare di -connessione. L'utilizzo del programma \cmd{netstat} permette di visualizzare -queste informazioni nei campi \textit{Local Address} e \textit{Foreing - Address}. - - -\subsection{Le porte ed il modello client/server} -\label{sec: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 descriveremo in -\secref{sec:TCP_daytime_application} e \secref{sec:TCP_echo_application}) -esamineremo cosa accade con le connessioni nel caso di un server TCP che deve -gestire connessioni multiple. - -Se eseguiamo un \cmd{netstat} su una macchina di prova (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{Le funzioni di base per la gestione dei socket} -\label{sec:TCP_functions} - -In questa sezione descriveremo in maggior dettaglio le varie funzioni che -vengono usate per la gestione di base dei socket TCP, non torneremo però sulla -funzione \func{socket}, che è già stata esaminata accuratamente nel capitolo -precedente in \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 i socket TCP la chiamata \func{bind} permette di specificare l'indirizzo, -la porta, entrambi o nessuno dei due. In genere i server utilizzano una porta -nota che assegnano all'avvio, se questo non viene fatto è il kernel a -scegliere una porta effimera quando vengono eseguite la funzioni -\func{connect} o \func{listen}, ma se questo è normale per il client non lo è -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 dipenderà dalle -regole di instradamento usate per raggiungere il server). Se un server non -specifica il suo indirizzo locale il kernel userà come indirizzo di origine -l'indirizzo di destinazione specificato dal SYN del client. - -Per specificare un indirizzo generico, con IPv4 si usa il valore -\const{INADDR\_ANY}, il cui valore, come accennato in -\secref{sec:sock_sa_ipv4}, è pari a zero; nell'esempio -\figref{fig:TCP_daytime_iter_server_code} si è usata un'assegnazione immediata -del tipo: \includecodesnip{listati/serv_addr_sin_addr.c} - -Si noti che si è usato \func{htonl} per assegnare il valore -\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, nel qual caso \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} (torneremo su questo in \secref{sec:TCP_echo_critical}). -Un'altra differenza con BSD è che la funzione non fa ereditare al nuovo socket -i flag del socket originale, come \const{O\_NONBLOCK},\footnote{ed in generale - tutti quelli che si possono impostare con \func{fcntl}, vedi - \secref{sec:file_fcntl}.} che devono essere rispecificati ogni volta. Tutto -questo deve essere tenuto in conto se si devono scrivere programmi portabili. - -Il meccanismo di funzionamento di \func{accept} è essenziale per capire il -funzionamento di un server: in generale infatti c'è sempre un solo socket in -ascolto, detto per questo \textit{listening socket}, che resta per tutto il -tempo nello stato \texttt{LISTEN}, mentre le connessioni vengono gestite dai -nuovi socket, detti \textit{connected socket}, ritornati da \func{accept}, che -si trovano automaticamente nello stato \texttt{ESTABLISHED}, e vengono -utilizzati per lo scambio dei dati, che avviene su di essi, fino alla chiusura -della connessione. Si può riconoscere questo schema anche nell'esempio -elementare di \figref{fig:TCP_daytime_iter_server_code}, dove per ogni -connessione il socket creato da \func{accept} viene chiuso dopo l'invio dei -dati. - - -\subsection{Le funzioni \func{getsockname} e \func{getpeername}} -\label{sec:TCP_get_names} - -Oltre a tutte quelle viste finora, dedicate all'utilizzo dei socket, esistono -alcune funzioni ausiliarie che possono essere usate per recuperare alcune -informazioni relative ai socket ed alle connessioni ad essi associate. Le due -funzioni più elementari sono queste, che vengono usate per ottenere i dati -relativi alla socket pair associata ad un certo socket. - -La prima funzione è \funcd{getsockname} e serve ad ottenere l'indirizzo locale -associato ad un socket; il suo prototipo è: -\begin{prototype}{sys/socket.h} - {int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)} - Legge l'indirizzo locale di un socket. - -\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di - errore. I codici di errore restituiti in \var{errno} sono i seguenti: - \begin{errlist} - \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor - valido. - \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket. - \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per - eseguire l'operazione. - \item[\errcode{EFAULT}] l'indirizzo \param{name} non è valido. - \end{errlist}} -\end{prototype} - -La funzione restituisce la struttura degli indirizzi del socket \param{sockfd} -nella struttura indicata dal puntatore \param{name} la cui lunghezza è -specificata tramite l'argomento \param{namlen}. Quest'ultimo viene passato -come indirizzo per avere indietro anche il numero di byte effettivamente -scritti nella struttura puntata da \param{name}. Si tenga presente che se si è -utilizzato un buffer troppo piccolo per \param{name} l'indirizzo risulterà -troncato. - -La funzione si usa tutte le volte che si vuole avere l'indirizzo locale di un -socket; ad esempio può essere usata da un client (che usualmente non chiama -\func{bind}) per ottenere numero IP e porta locale associati al socket -restituito da una \func{connect}, o da un server che ha chiamato \func{bind} -su un socket usando 0 come porta locale per ottenere il numero di porta -effimera assegnato dal kernel. - -Inoltre quando un server esegue una \func{bind} su un indirizzo generico, se -chiamata dopo il completamento di una connessione sul socket restituito da -\func{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a -quella connessione. - -Tutte le volte che si vuole avere l'indirizzo remoto di un socket si usa la -funzione \funcd{getpeername}, il cui prototipo è: -\begin{prototype}{sys/socket.h} - {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)} - Legge l'indirizzo remoto di un socket. - - \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di - errore. I codici di errore restituiti in \var{errno} sono i seguenti: - \begin{errlist} - \item[\errcode{EBADF}] l'argomento \param{sockfd} non è un file descriptor - valido. - \item[\errcode{ENOTSOCK}] l'argomento \param{sockfd} non è un socket. - \item[\errcode{ENOTCONN}] il socket non è connesso. - \item[\errcode{ENOBUFS}] non ci sono risorse sufficienti nel sistema per - eseguire l'operazione. - \item[\errcode{EFAULT}] l'argomento \param{name} punta al di fuori dello - spazio di indirizzi del processo. - \end{errlist}} -\end{prototype} - -La funzione è identica a \func{getsockname}, ed usa la stessa sintassi, ma -restituisce l'indirizzo remoto del socket, cioè quello associato all'altro -capo della connessione. Ci si può chiedere a cosa serva questa funzione dato -che dal lato client l'indirizzo remoto è sempre noto quando si esegue la -\func{connect} mentre dal lato server si possono usare, come vedremo in -\figref{fig:TCP_daytime_cunc_server_code}, i valori di ritorno di -\func{accept}. - -Il fatto è che in generale quest'ultimo caso non è sempre possibile. In -particolare questo avviene quando il server, invece di gestire la connessione -direttamente in un processo figlio, come vedremo nell'esempio di server -concorrente di \secref{sec:TCP_daytime_cunc_server}, lancia per ciascuna -connessione un altro programma, usando \func{exec}.\footnote{questa ad esempio - è la modalità con cui opera il \textsl{super-server} \cmd{inetd}, che può - gestire tutta una serie di servizi diversi, eseguendo su ogni connessione - ricevuta sulle porte tenute sotto controllo, il relativo server.} - -In questo caso benché il processo figlio abbia una immagine della memoria che -è copia di quella del processo padre (e contiene quindi anche la struttura -ritornata da \func{accept}), all'esecuzione di \func{exec} verrà caricata in -memoria l'immagine del programma eseguito, che a questo punto perde ogni -riferimento ai valori tornati da \func{accept}. Il socket descriptor però -resta aperto, e se si è seguita una opportuna convenzione per rendere noto al -programma eseguito qual'è il socket connesso, \footnote{ad esempio il solito - \cmd{inetd} fa sempre in modo che i file descriptor 0, 1 e 2 corrispondano - al socket connesso.} quest'ultimo potrà usare la funzione \func{getpeername} -per determinare l'indirizzo remoto del client. - -Infine è da chiarire (si legga la pagina di manuale) che, come per -\func{accept}, il terzo parametro, che è specificato dallo standard POSIX.1g -come di tipo \code{socklen\_t *} in realtà deve sempre corrispondere ad un -\ctyp{int *} come prima dello standard perché tutte le implementazioni dei -socket BSD fanno questa assunzione. - - -\subsection{La funzione \func{close}} -\label{sec: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 le funzioni di I/O, ma con i normali file di dati il -problema si avverte solo in lettura, quando si incontra la fine del file. In -generale non è così, e con i socket questo è particolarmente evidente. - - -\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. Entrambe le funzioni restituiscono 0 in caso di successo, ed un -valore negativo in caso di errore, \texttt{FullRead} restituisce il numero di -byte non letti in caso di end-of-file prematuro. - - -\subsection{Il client \textit{daytime}} -\label{sec:TCP_daytime_client} - -Il primo esempio di applicazione delle funzioni di base illustrate in -\secref{sec:TCP_functions} è relativo alla creazione di un client elementare -per il servizio \textit{daytime}, un servizio elementare, definito -nell'\href{http://www.ietf.org/rfc/rfc0867.txt}{RFC~867}, che restituisce -l'ora locale della macchina a cui si effettua la richiesta, e che è assegnato -alla porta 13. - -In \figref{fig:TCP_daytime_client_code} è riportata la sezione principale del -codice del nostro client. Il sorgente completo del programma -(\file{TCP\_daytime.c}, che comprende il trattamento delle opzioni ed una -funzione per stampare un messaggio di aiuto) è allegato alla guida nella -sezione dei codici sorgente e può essere compilato su una qualunque macchina -GNU/Linux. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15cm} - \includecodesample{listati/TCP_daytime.c} - \end{minipage} - \normalsize - \caption{Esempio di codice di un client elementare per il servizio - \textit{daytime}.} - \label{fig:TCP_daytime_client_code} -\end{figure} - -Il programma anzitutto (\texttt{\small 1--5}) include gli header necessari; -dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa -tutta la parte relativa al trattamento degli argomenti passati dalla linea di -comando (effettuata con le apposite funzioni illustrate in -\secref{sec:proc_opt_handling}). - -Il primo passo (\texttt{\small 14--18}) è creare un socket TCP (quindi di tipo -\const{SOCK\_STREAM} e di famiglia \const{AF\_INET}). La funzione -\func{socket} ritorna il descrittore che viene usato per identificare il -socket in tutte le chiamate successive. Nel caso la chiamata fallisca si -stampa un errore (\texttt{\small 16}) con la funzione \func{perror} e si esce -(\texttt{\small 17}) con un codice di errore. - -Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita -struttura \struct{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed -il numero della porta del servizio. Il primo passo (\texttt{\small 20}) è -inizializzare tutto a zero, per poi inserire il tipo di indirizzo -(\texttt{\small 21}) e la porta (\texttt{\small 22}), usando per quest'ultima -la funzione \func{htons} per convertire il formato dell'intero usato dal -computer a quello usato nella rete, infine \texttt{\small 23--27} si può -utilizzare la funzione \func{inet\_pton} per convertire l'indirizzo numerico -passato dalla linea di comando. - -A questo punto (\texttt{\small 28--32}) usando la funzione \func{connect} sul -socket creato in precedenza (\texttt{\small 29}) si può stabilire la -connessione con il server. Per questo si deve utilizzare come secondo -argomento la struttura preparata in precedenza con il relativo indirizzo; si -noti come, esistendo diversi tipi di socket, si sia dovuto effettuare un cast. -Un valore di ritorno della funzione negativo implica il fallimento della -connessione, nel qual caso si stampa un errore (\texttt{\small 30}) e si -ritorna (\texttt{\small 31}). - -Completata con successo la connessione il passo successivo (\texttt{\small - 34--40}) è leggere la data dal socket; il protocollo prevede che il server -invii sempre una stringa alfanumerica, il formato della stringa non è -specificato dallo standard, per cui noi useremo il formato usato dalla -funzione \func{ctime}, seguito dai caratteri di terminazione \verb|\r\n|, cioè -qualcosa del tipo: -\begin{verbatim} -Wed Apr 4 00:53:00 2001\r\n -\end{verbatim} -questa viene letta dal socket (\texttt{\small 34}) con la funzione \func{read} -in un buffer temporaneo; la stringa poi deve essere terminata (\texttt{\small - 35}) con il solito carattere nullo per poter essere stampata (\texttt{\small - 36}) sullo standard output con l'uso di \func{fputs}. - -Come si è già spiegato in \secref{sec:sock_io_behav} la risposta dal socket -potrà arrivare in un unico pacchetto di 26 byte (come avverrà senz'altro nel -caso in questione) ma potrebbe anche arrivare in 26 pacchetti di un byte. Per -questo nel caso generale non si può mai assumere che tutti i dati arrivino con -una singola lettura, pertanto quest'ultima deve essere effettuata in un ciclo -in cui si continui a leggere fintanto che la funzione \func{read} non ritorni -uno zero (che significa che l'altro capo ha chiuso la connessione) o un numero -minore di zero (che significa un errore nella connessione). - -Si noti come in questo caso la fine dei dati sia specificata dal server che -chiude la connessione (anche questo è quanto richiesto dal protocollo); questa -è una delle tecniche possibili (è quella usata pure dal protocollo HTTP), ma -ce ne possono essere altre, ad esempio FTP marca la conclusione di un blocco -di dati con la sequenza ASCII \verb|\r\n| (carriage return e line feed), -mentre il DNS mette la lunghezza in testa ad ogni blocco che trasmette. Il -punto essenziale è che TCP non provvede nessuna indicazione che permetta di -marcare dei blocchi di dati, per cui se questo è necessario deve provvedere il -programma stesso. - -Se abilitiamo il servizio \textit{daytime}\footnote{in genere questo viene - fornito direttamente dal \textsl{superdemone} \texttt{inetd}, pertanto basta - assicurarsi che esso sia abilitato nel relativo file di configurazione.} -possiamo verificare il funzionamento del nostro client, avremo allora: -\begin{verbatim} -[piccardi@gont sources]$ ./daytime 127.0.0.1 -Mon Apr 21 20:46:11 2003 -\end{verbatim}%$ -e come si vede tutto funziona regolarmente. - - -\subsection{Un server \textit{daytime} iterativo} -\label{sec:TCP_daytime_iter_server} - -Dopo aver illustrato il client daremo anche un esempio di un server -elementare, che sia anche in grado di rispondere al precedente client. Come -primo esempio realizzeremo un server iterativo, in grado di fornire una sola -risposta alla volta. Il codice del programma è nuovamente mostrato in -\figref{fig:TCP_daytime_iter_server_code}, il sorgente completo -(\file{TCP\_iter\_daytimed.c}) è allegato insieme agli altri file degli esempi. - -\begin{figure}[!htbp] - \footnotesize \centering - \begin{minipage}[c]{15cm} - \includecodesample{listati/TCP_iter_daytimed.c} - \end{minipage} - \normalsize - \caption{Esempio di codice di un semplice server per il servizio daytime.} - \label{fig:TCP_daytime_iter_server_code} -\end{figure} - -Come per il client si includono (\texttt{\small 1--9}) gli header necessari a -cui è aggiunto quello per trattare i tempi, e si definiscono (\texttt{\small - 14--18}) alcune costanti e le variabili necessarie in seguito. Come nel caso -precedente si sono omesse le parti relative al trattamento delle opzioni da -riga di comando. - -La creazione del socket (\texttt{\small 20--24}) è analoga al caso precedente, -come pure l'inizializzazione (\texttt{\small 25--29}) della struttura -\struct{sockaddr\_in}. Anche in questo caso (\texttt{\small 28}) si usa la -porta standard del servizio daytime, ma come indirizzo IP si usa -(\texttt{\small 27}) il valore predefinito \const{INET\_ANY}, che corrisponde -all'indirizzo generico. - -Si effettua poi (\texttt{\small 30--34}) la chiamata alla funzione \func{bind} -che permette di associare la precedente struttura al socket, in modo che -quest'ultimo possa essere usato per accettare connessioni su una qualunque -delle interfacce di rete locali. In caso di errore si stampa (\texttt{\small - 31}) un messaggio, e si termina (\texttt{\small 32}) immediatamente il -programma. - -Il passo successivo (\texttt{\small 35--39}) è quello di mettere ``in -ascolto'' il socket; questo viene fatto (\texttt{\small 36}) con la funzione -\func{listen} che dice al kernel di accettare connessioni per il socket che -abbiamo creato; la funzione indica inoltre, con il secondo parametro, il -numero massimo di connessioni che il kernel accetterà di mettere in coda per -il suddetto socket. Di nuovo in caso di errore si stampa (\texttt{\small 37}) -un messaggio, e si esce (\texttt{\small 38}) immediatamente. - -La chiamata a \func{listen} completa la preparazione del socket per l'ascolto -(che viene chiamato anche \textit{listening descriptor}) a questo punto si può -procedere con il ciclo principale (\texttt{\small 40--53}) che viene eseguito -indefinitamente. Il primo passo (\texttt{\small 42}) è porsi in attesa di -connessioni con la chiamata alla funzione \func{accept}, come in precedenza in -caso di errore si stampa (\texttt{\small 43}) un messaggio, e si esce -(\texttt{\small 44}). - -Il processo resterà in stato di \textit{sleep} fin quando non arriva e viene -accettata una connessione da un client; quando questo avviene \func{accept} -ritorna, restituendo un secondo descrittore, che viene chiamato -\textit{connected descriptor}, e che è quello che verrà usato dalla successiva -chiamata alla \func{write} per scrivere la risposta al client. - -Il ciclo quindi proseguirà determinando (\texttt{\small 46}) il tempo corrente -con una chiamata a \texttt{time}, con il quale si potrà opportunamente -costruire (\texttt{\small 47}) la stringa con la data da trasmettere -(\texttt{\small 48}) con la chiamata a \func{write}. Completata la -trasmissione il nuovo socket viene chiuso (\texttt{\small 52}). A questo -punto il ciclo si chiude ricominciando da capo in modo da poter ripetere -l'invio della data in risposta ad una successiva connessione. - -È importante notare che questo server è estremamente elementare, infatti, a -parte il fatto di poter essere usato solo con indirizzi IPv4, esso è in grado -di rispondere ad un solo un client alla volta: è cioè, come dicevamo, un -\textsl{server iterativo}. Inoltre è scritto per essere lanciato da linea di -comando, se lo si volesse utilizzare come demone occorrerebbero le opportune -modifiche\footnote{come una chiamata a \func{daemon} prima dell'inizio del - ciclo principale.} per tener conto di quanto illustrato in -\secref{sec:sess_daemon}. Si noti anche che non si è inserita nessuna forma di -gestione della terminazione del processo, dato che tutti i file descriptor -vengono chiusi automaticamente alla sua uscita, e che, non generando figli, -non è necessario preoccuparsi di gestire la loro terminazione. - - -\subsection{Un server \textit{daytime} concorrente} -\label{sec:TCP_daytime_cunc_server} - -Il server \texttt{daytime} dell'esempio in -\secref{sec:TCP_daytime_iter_server} è un tipico esempio di server iterativo, -in cui viene servita una richiesta alla volta; in generale però, specie se il -servizio è più complesso e comporta uno scambio di dati più sostanzioso di -quello in questione, non è opportuno bloccare un server nel servizio di un -client per volta; per questo si ricorre alle capacità di multitasking del -sistema. - -Come accennato anche in \secref{sec:proc_gen} una delle modalità più comuni di -funzionamento da parte dei server è quella di usare la funzione \func{fork} -per creare, ad ogni richiesta da parte di un client, un processo figlio che si -incarichi della gestione della comunicazione. Si è allora riscritto il server -\textit{daytime} dell'esempio precedente in forma concorrente, inserendo anche -una opzione per la stampa degli indirizzi delle connessioni ricevute. - -In \figref{fig:TCP_daytime_cunc_server_code} è mostrato un estratto del -codice, in cui si sono tralasciati il trattamento delle opzioni e le parti -rimaste invariate rispetto al precedente esempio (cioè tutta la parte -riguardante l'apertura passiva del socket). Al solito il sorgente completo del -server, nel file \file{TCP\_cunc\_daytimed.c}, è allegato insieme ai sorgenti -degli altri esempi. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15cm} - \includecodesample{listati/TCP_cunc_daytimed.c} - \end{minipage} - \normalsize - \caption{Esempio di codice di un server concorrente elementare per il - servizio daytime.} - \label{fig: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 (\texttt{\small 47}) solo sul socket in ascolto chiudendo -\var{sock\_fd} al ritorno dalla \func{fork}. Per quanto abbiamo detto in -\secref{sec:TCP_func_close} nessuna delle due chiamate a \func{close} causa -l'innesco della sequenza di chiusura perché il numero di riferimenti al file -descriptor non si è annullato. - -Infatti subito dopo la creazione del socket \var{list\_fd} ha una referenza, e -lo stesso vale per \var{sock\_fd} dopo il ritorno di \func{accept}, ma dopo la -\func{fork} i descrittori vengono duplicati nel padre e nel figlio per cui -entrambi i socket si trovano con due referenze. Questo fa si che quando il -padre chiude \var{sock\_fd} esso resta con una referenza da parte del figlio, -e sarà definitivamente chiuso solo quando quest'ultimo, dopo aver completato -le sue operazioni, chiamerà (\texttt{\small 44}) la funzione \func{close}. - -In realtà per il figlio non sarebbe necessaria nessuna chiamata a -\func{close}, in quanto con la \func{exit} finale (\texttt{\small 45}) tutti i -file descriptor, quindi anche quelli associati ai socket, vengono -automaticamente chiusi. Tuttavia si è preferito effettuare esplicitamente le -chiusure per avere una maggiore chiarezza del codice, e per evitare eventuali -errori, prevenendo ad esempio un uso involontario del \textit{listening - descriptor}. - -Si noti invece come sia essenziale che il padre chiuda ogni volta il socket -connesso dopo la \func{fork}; se così non fosse nessuno di questi socket -sarebbe effettivamente chiuso dato che alla chiusura da parte del figlio -resterebbe ancora un riferimento nel padre. Si avrebbero così due effetti: il -padre potrebbe esaurire i descrittori disponibili (che sono un numero limitato -per ogni processo) e soprattutto nessuna delle connessioni con i client -verrebbe chiusa. - -Come per ogni server iterativo il lavoro di risposta viene eseguito -interamente dal processo figlio. Questo si incarica (\texttt{\small 33}) di -chiamare \func{time} per leggere il tempo corrente, e di stamparlo -(\texttt{\small 34}) sulla stringa contenuta in \var{buffer} con l'uso di -\func{snprintf} e \func{ctime}. Poi la stringa viene scritta (\texttt{\small - 35--38}) sul socket, controllando che non ci siano errori. Anche in questo -caso si è evitato il ricorso a \func{FullWrite} in quanto la stringa è -estremamente breve e verrà senz'altro scritta in un singolo segmento. - -Inoltre nel caso sia stato abilitato il \textit{logging} delle connessioni, si -provvede anche (\texttt{\small 39--42}) a stampare sullo standard output -l'indirizzo e la porta da cui il client ha effettuato la connessione, usando -i valori contenuti nelle strutture restituite da \func{accept}, eseguendo le -opportune conversioni con \func{inet\_ntop} e \func{atohs}. - -Ancora una volta l'esempio è estremamente semplificato, si noti come di nuovo -non si sia gestita né la terminazione del processo né il suo uso come demone, -che tra l'altro sarebbe stato incompatibile con l'uso della opzione di logging -che stampa gli indirizzi delle connessioni sullo standard output. Un altro -aspetto tralasciato è la gestione della terminazione dei processi figli, -torneremo su questo più avanti quando tratteremo alcuni esempi di server più -complessi. - - - -\section{Un esempio più completo: il servizio \textit{echo}} -\label{sec:TCP_echo_application} - -L'esempio precedente, basato sul servizio \textit{daytime}, è un esempio molto -elementare, in cui il flusso dei dati va solo nella direzione dal server al -client. In questa sezione esamineremo un esempio di applicazione client/server -un po' più complessa, che usi i socket TCP per una comunicazione in entrambe -le direzioni. - -Ci limiteremo a fornire una implementazione elementare, che usi solo le -funzioni di base viste finora, ma prenderemo in esame, oltre al comportamento -in condizioni normali, anche tutti i possibili scenari particolari (errori, -sconnessione della rete, crash del client o del server durante la connessione) -che possono avere luogo durante l'impiego di un'applicazione di rete, partendo -da una versione primitiva che dovrà essere rimaneggiata di volta in volta per -poter tenere conto di tutte le evenienze che si possono manifestare nella vita -reale di un'applicazione di rete, fino ad arrivare ad un'implementazione -completa. - - -\subsection{Il servizio \textit{echo}} -\label{sec:TCP_echo} - - -Nella ricerca di un servizio che potesse fare da esempio per una comunicazione -bidirezionale, si è deciso, seguendo la scelta di Stevens in \cite{UNP1}, di -usare il servizio \textit{echo}, che si limita a restituire in uscita quanto -immesso in ingresso. Infatti, nonostante la sua estrema semplicità, questo -servizio costituisce il prototipo ideale per una generica applicazione di rete -in cui un server risponde alle richieste di un client. Nel caso di una -applicazione più complessa quello che si potrà avere in più è una elaborazione -dell'input del client, che in molti casi viene interpretato come un comando, -da parte di un server che risponde fornendo altri dati in uscita. - -Il servizio \textit{echo} è uno dei servizi standard solitamente provvisti -direttamente dal superserver \cmd{inetd}, ed è definito -dall'\href{http://www.ietf.org/rfc/rfc0862.txt}{RFC~862}. Come dice il nome il -servizio deve riscrivere indietro sul socket i dati che gli vengono inviati in -ingresso. L'RFC descrive le specifiche del servizio sia per TCP che UDP, e per -il primo stabilisce che una volta stabilita la connessione ogni dato in -ingresso deve essere rimandato in uscita fintanto che il chiamante non ha -chiude la connessione. Al servizio è assegnata la porta riservata 7. - -Nel nostro caso l'esempio sarà costituito da un client che legge una linea di -caratteri dallo standard input e la scrive sul server. A sua volta il server -leggerà la linea dalla connessione e la riscriverà immutata all'indietro. Sarà -compito del client leggere la risposta del server e stamparla sullo standard -output. - - -\subsection{Il client: prima versione} -\label{sec:TCP_echo_client} - -Il codice della prima versione del client per il servizio \textit{echo}, -disponibile nel file \file{TCP\_echo\_first.c}, è riportato in -\figref{fig:TCP_echo_client_1}. Esso ricalca la struttura del precedente -client per il servizio \textit{daytime} (vedi -\secref{sec:TCP_daytime_client}), e la prima parte (\texttt{\small 10--27}) è -sostanzialmente identica, a parte l'uso di una porta diversa. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6 cm} - \includecodesample{listati/TCP_echo_first.c} - \end{minipage} - \normalsize - \caption{Codice della prima versione del client \textit{echo}.} - \label{fig:TCP_echo_client_1} -\end{figure} - -Al solito si è tralasciata la sezione relativa alla gestione delle opzioni a -riga di comando. Una volta dichiarate le variabili, si prosegue -(\texttt{\small 10--13}) con della creazione del socket con l'usuale controllo -degli errori, alla preparazione (\texttt{\small 14--17}) della struttura -dell'indirizzo, che stavolta usa la porta 7 riservata al servizio -\textit{echo}, infine si converte (\texttt{\small 18--22}) l'indirizzo -specificato a riga di comando. A questo punto (\texttt{\small 23--27}) si può -eseguire la connessione al server secondo la stessa modalità usata in -\secref{sec:TCP_daytime_client}. - -Completata la connessione, per gestire il funzionamento del protocollo si usa -la funzione \code{ClientEcho}, il cui codice si è riportato a parte in -\figref{fig:TCP_client_echo_sub}. Questa si preoccupa di gestire tutta la -comunicazione, leggendo una riga alla volta dallo standard input \file{stdin}, -scrivendola sul socket e ristampando su \file{stdout} quanto ricevuto in -risposta dal server. Al ritorno dalla funzione (\texttt{\small 30--31}) anche -il programma termina. - -La funzione \code{ClientEcho} utilizza due buffer (\texttt{\small 3}) per -gestire i dati inviati e letti sul socket. La comunicazione viene gestita -all'interno di un ciclo (\texttt{\small 5--10}), i dati da inviare sulla -connessione vengono presi dallo \file{stdin} usando la funzione \func{fgets}, -che legge una linea di testo (terminata da un \texttt{CR} e fino al massimo di -\const{MAXLINE} caratteri) e la salva sul buffer di invio. - -Si usa poi (\texttt{\small 6}) la funzione \func{FullWrite}, vista in -\secref{sec:sock_io_behav}, per scrivere i dati sul socket, gestendo -automaticamente l'invio multiplo qualora una singola \func{write} non sia -sufficiente. I dati vengono riletti indietro (\texttt{\small 7}) con una -\func{read}\footnote{si è fatta l'assunzione implicita che i dati siano - contenuti tutti in un solo segmento, così che la chiamata a \texttt{read} li - restituisca sempre tutti; avendo scelto una dimensione ridotta per il buffer - questo sarà sempre vero, vedremo più avanti come superare il problema di - rileggere indietro tutti e soli i dati disponibili, senza bloccarsi.} sul -buffer di ricezione e viene inserita (\texttt{\small 8}) la terminazione della -stringa e per poter usare (\texttt{\small 9}) la funzione \func{fputs} per -scriverli su \file{stdout}. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/ClientEcho.c} - \end{minipage} - \normalsize - \caption{Codice della prima versione della funzione \texttt{ClientEcho} per - la gestione del servizio \textit{echo}.} - \label{fig:TCP_client_echo_sub} -\end{figure} - -Quando si concluderà l'invio di dati mandando un end-of-file sullo standard -input si avrà il ritorno di \func{fgets} con un puntatore nullo (si riveda -quanto spiegato in \secref{sec:file_line_io}) e la conseguente uscita dal -ciclo; al che la subroutine ritorna ed il nostro programma client termina. - -Si può effettuare una verifica del funzionamento del client abilitando il -servizio \textit{echo} nella configurazione di \cmd{initd} sulla propria -macchina ed usandolo direttamente verso di esso in locale, vedremo in -dettaglio più avanti (in \secref{sec:TCP_echo_startup}) il funzionamento del -programma, usato però con la nostra versione del server \textit{echo}, che -illustriamo immediatamente. - - -\subsection{Il server: prima versione} -\label{sec:TCPsimp_server_main} - -La prima versione del server, contenuta nel file \file{TCP\_echod\_first.c}, è -riportata in \figref{fig:TCP_echo_server_first_code}. Come abbiamo fatto per -il client anche il server è stato diviso in un corpo principale, costituito -dalla funzione \code{main}, che è molto simile a quello visto nel precedente -esempio per il server del servizio \textit{daytime} di -\secref{sec:TCP_daytime_cunc_server}, e da una funzione ausiliaria -\code{ServEcho} che si cura della gestione del servizio. - -\begin{figure}[!htbp] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/TCP_echod_first.c} - \end{minipage} - \normalsize - \caption{Codice del corpo principale della prima versione del server - per il servizio \textit{echo}.} - \label{fig:TCP_echo_server_first_code} -\end{figure} - -In questo caso però, rispetto a quanto visto nell'esempio di -\figref{fig:TCP_daytime_cunc_server_code} si è preferito scrivere il server -curando maggiormente alcuni dettagli, per tenere conto anche di alcune -esigenze generali (che non riguardano direttamente la rete), come la -possibilità di lanciare il server anche in modalità interattiva e la cessione -dei privilegi di amministratore non appena questi non sono più necessari. - -La sezione iniziale del programma (\texttt{\small 8--21}) è la stessa del -server di \secref{sec:TCP_daytime_cunc_server}, ed ivi descritta in dettaglio: -crea il socket, inizializza l'indirizzo e esegue \func{bind}; dato che -quest'ultima funzione viene usata su una porta riservata, il server dovrà -essere eseguito da un processo con i privilegi di amministratore, pena il -fallimento della chiamata. - -Una volta eseguita la funzione \func{bind} però i privilegi di amministratore -non sono più necessari, per questo è sempre opportuno rilasciarli, in modo da -evitare problemi in caso di eventuali vulnerabilità del server. Per questo -prima (\texttt{\small 22--26}) si esegue \func{setgid} per assegnare il -processo ad un gruppo senza privilegi,\footnote{si è usato il valore 65534, - ovvero -1 per il formato \ctyp{short}, che di norma in tutte le - distribuzioni viene usato per identificare il gruppo \texttt{nogroup} e - l'utente \texttt{nobody}, usati appunto per eseguire programmi che non - richiedono nessun privilegio particolare.} e poi si ripete (\texttt{\small - 27--30}) l'operazione usando \func{setuid} per cambiare anche -l'utente.\footnote{si tenga presente che l'ordine in cui si eseguono queste - due operazioni è importante, infatti solo avendo i privilegi di - amministratore si può cambiare il gruppo di un processo ad un'altro di cui - non si fa parte, per cui chiamare prima \func{setuid} farebbe fallire una - successiva chiamata a \func{setgid}. Inoltre si ricordi (si riveda quanto - esposto in \secref{sec:proc_perms}) che usando queste due funzioni il - rilascio dei privilegi è irreversibile.} Infine (\texttt{\small 30--36}), -qualora sia impostata la variabile \var{demonize}, prima (\texttt{\small 31}) -si apre il sistema di logging per la stampa degli errori, e poi -(\texttt{\small 32--35}) si invoca \func{daemon} per eseguire in background il -processo come demone. - -A questo punto il programma riprende di nuovo lo schema già visto usato dal -server per il servizio \textit{daytime}, con l'unica differenza della chiamata -alla funzione \code{PrintErr}, riportata in \figref{fig:TCP_PrintErr}, al -posto di \func{perror} per la stampa degli errori. - -Si inizia con il porre (\texttt{\small 37--41}) in ascolto il socket, e poi si -esegue indefinitamente il ciclo principale (\texttt{\small 42--58}). -All'interno di questo si ricevono (\texttt{\small 43--46}) le connessioni, -creando (\texttt{\small 47--50}) un processo figlio per ciascuna di esse. -Quest'ultimo (\texttt{\small 51--55}), chiuso (\texttt{\small 52}) il -\textit{listening socket}, esegue (\texttt{\small 53}) la funzione di gestione -del servizio \code{ServEcho}, ed al ritorno di questa (\texttt{\small 54}) -esce. - -Il padre invece si limita (\texttt{\small 56}) a chiudere il \textit{connected - socket} per ricominciare da capo il ciclo in attesa di nuove connessioni. In -questo modo si ha un server concorrente. La terminazione del padre non è -gestita esplicitamente, e deve essere effettuata inviando un segnale al -processo. - -Avendo trattato direttamente la gestione del programma come demone, si è -dovuto anche provvedere alla necessità di poter stampare eventuali messaggi di -errore attraverso il sistema del \textit{syslog} trattato in -\secref{sec:sess_daemon}. Come accennato questo è stato fatto utilizzando come -\textit{wrapper} la funzione \code{PrintErr}, il cui codice è riportato in -\figref{fig:TCP_PrintErr}. - -In essa ci si limita a controllare (\texttt{\small 2}) se è stato impostato -(valore attivo per default) l'uso come demone, nel qual caso (\texttt{\small - 3}) si usa \func{syslog} (vedi \secref{sec:sess_daemon}) per stampare il -messaggio di errore fornito come argomento sui log di sistema. Se invece si è -in modalità interattiva (attivabile con l'opzione \texttt{-i}) si usa -(\texttt{\small 5}) semplicemente la funzione \func{perror} per stampare sullo -standard error. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/PrintErr.c} - \end{minipage} - \normalsize - \caption{Codice della funzione \code{PrintErr} per la - generalizzazione della stampa degli errori sullo standard input o - attraverso il \texttt{syslog}.} - \label{fig:TCP_PrintErr} -\end{figure} - -La gestione del servizio \textit{echo} viene effettuata interamente nella -funzione \code{ServEcho}, il cui codice è mostrato in -\figref{fig:TCP_ServEcho_first}, e la comunicazione viene gestita all'interno -di un ciclo (\texttt{\small 6--13}). I dati inviati dal client vengono letti -(\texttt{\small 6}) dal socket con una semplice \func{read}, di cui non si -controlla lo stato di uscita, assumendo che ritorni solo in presenza di dati -in arrivo. La riscrittura (\texttt{\small 7}) viene invece gestita dalla -funzione \func{FullWrite} (descritta in \figref{fig:sock_FullWrite_code}) che -si incarica di tenere conto automaticamente della possibilità che non tutti i -dati di cui è richiesta la scrittura vengano trasmessi con una singola -\func{write}. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/ServEcho_first.c} - \end{minipage} - \normalsize - \caption{Codice della prima versione della funzione \code{ServEcho} per la - gestione del servizio \textit{echo}.} - \label{fig:TCP_ServEcho_first} -\end{figure} - -In caso di errore di scrittura (si ricordi che \func{FullWrite} restituisce un -valore nullo in caso di successo) si provvede (\texttt{\small 8--10}) a -stampare il relativo messaggio con \func{PrintErr}. Quando il client chiude -la connessione il ricevimento del FIN fa ritornare la \func{read} con un -numero di byte letti pari a zero, il che causa l'uscita dal ciclo e il ritorno -(\texttt{\small 12}) della funzione, che a sua volta causa la terminazione del -processo figlio. - - -\subsection{L'avvio e il funzionamento normale} -\label{sec:TCP_echo_startup} - -Benché il codice dell'esempio precedente sia molto ridotto, esso ci permetterà -di considerare in dettaglio le varie problematiche che si possono incontrare -nello scrivere un'applicazione di rete. Infatti attraverso l'esame delle sue -modalità di funzionamento normali, all'avvio e alla terminazione, e di quello -che avviene nelle varie situazioni limite, da una parte potremo approfondire -la comprensione del protocollo TCP/IP e dall'altra ricavare le indicazioni -necessarie per essere in grado di scrivere applicazioni robuste, in grado di -gestire anche i casi limite. - -Il primo passo è compilare e lanciare il server (da root, per poter usare la -porta 7 che è riservata), alla partenza esso eseguirà l'apertura passiva con -la sequenza delle chiamate a \func{socket}, \func{bind}, \func{listen} e poi -si bloccherà nella \func{accept}. A questo punto si potrà controllarne lo -stato con \cmd{netstat}: -\begin{verbatim} -[piccardi@roke piccardi]$ netstat -at -Active Internet connections (servers and established) -Proto Recv-Q Send-Q Local Address Foreign Address State -... -tcp 0 0 *:echo *:* LISTEN -... -\end{verbatim} %$ -che ci mostra come il socket sia in ascolto sulla porta richiesta, accettando -connessioni da qualunque indirizzo e da qualunque porta e su qualunque -interfaccia locale. - -A questo punto si può lanciare il client, esso chiamerà \func{socket} e -\func{connect}; una volta completato il three way handshake la connessione è -stabilita; la \func{connect} ritornerà nel client\footnote{si noti che è - sempre la \func{connect} del client a ritornare per prima, in quanto - questo avviene alla ricezione del secondo segmento (l'ACK del server) del - three way handshake, la \func{accept} del server ritorna solo dopo - un altro mezzo RTT quando il terzo segmento (l'ACK del client) viene - ricevuto.} e la \func{accept} nel server, ed usando di nuovo -\cmd{netstat} otterremmo che: -\begin{verbatim} -Active Internet connections (servers and established) -Proto Recv-Q Send-Q Local Address Foreign Address State -tcp 0 0 *:echo *:* LISTEN -tcp 0 0 roke:echo gont:32981 ESTABLISHED -\end{verbatim} -mentre per quanto riguarda l'esecuzione dei programmi avremo che: -\begin{itemize} -\item il client chiama la funzione \code{ClientEcho} che si blocca sulla - \func{fgets} dato che non si è ancora scritto nulla sul terminale. -\item il server eseguirà una \func{fork} facendo chiamare al processo figlio - la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read} - dal socket sul quale ancora non sono presenti dati. -\item il processo padre del server chiamerà di nuovo \func{accept} - bloccandosi fino all'arrivo di un'altra connessione. -\end{itemize} -e se usiamo il comando \cmd{ps} per esaminare lo stato dei processi otterremo -un risultato del tipo: -\begin{verbatim} -[piccardi@roke piccardi]$ ps ax - PID TTY STAT TIME COMMAND - ... ... ... ... ... - 2356 pts/0 S 0:00 ./echod - 2358 pts/1 S 0:00 ./echo 127.0.0.1 - 2359 pts/0 S 0:00 ./echod -\end{verbatim} %$ -(dove si sono cancellate le righe inutili) da cui si evidenzia la presenza di -tre processi, tutti in stato di \textit{sleep} (vedi -\tabref{tab:proc_proc_states}). - -Se a questo punto si inizia a scrivere qualcosa sul client non sarà trasmesso -niente fin tanto che non si prema il tasto di a capo (si ricordi quanto detto -in \secref{sec:file_line_io} a proposito dell'I/O su terminale), solo allora -\func{fgets} ritornerà ed il client scriverà quanto immesso sul socket, per -poi passare a rileggere quanto gli viene inviato all'indietro dal server, che -a sua volta sarà inviato sullo standard output, che nel caso ne provoca -l'immediatamente stampa a video. - - -\subsection{La conclusione normale} -\label{sec:TCP_echo_conclusion} - -Tutto quello che scriveremo sul client sarà rimandato indietro dal server e -ristampato a video fintanto che non concluderemo l'immissione dei dati; una -sessione tipica sarà allora del tipo: -\begin{verbatim} -[piccardi@roke sources]$ ./echo 127.0.0.1 -Questa e` una prova -Questa e` una prova -Ho finito -Ho finito -\end{verbatim} %$ -che termineremo inviando un EOF dal terminale (usando la combinazione di tasti -ctrl-D, che non compare a schermo); se eseguiamo un \cmd{netstat} a questo -punto avremo: -\begin{verbatim} -[piccardi@roke piccardi]$ netstat -at -tcp 0 0 *:echo *:* LISTEN -tcp 0 0 localhost:33032 localhost:echo TIME_WAIT -\end{verbatim} %$ -con il client che entra in \texttt{TIME\_WAIT}. - -Esaminiamo allora in dettaglio la sequenza di eventi che porta alla -terminazione normale della connessione, che ci servirà poi da riferimento -quando affronteremo il comportamento in caso di conclusioni anomale: - -\begin{enumerate} -\item inviando un carattere di EOF da terminale la \func{fgets} ritorna - restituendo un puntatore nullo che causa l'uscita dal ciclo di \code{while}, - così la funzione \code{ClientEcho} ritorna. -\item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e - come parte del processo terminazione tutti i file descriptor vengono chiusi - (si ricordi quanto detto in \secref{sec:proc_term_conclusion}); questo causa - la chiusura del socket di comunicazione; il client allora invierà un FIN al - server a cui questo risponderà con un ACK. A questo punto il client verrà a - trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato - \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in - \secref{sec:TCP_conn_term}). -\item quando il server riceve il FIN la \func{read} del processo figlio che - gestisce la connessione ritorna restituendo 0 causando così l'uscita dal - ciclo e il ritorno di \code{ServEcho}, a questo punto il processo figlio - termina chiamando \func{exit}. -\item all'uscita del figlio tutti i file descriptor vengono chiusi, la - chiusura del socket connesso fa sì che venga effettuata la sequenza finale - di chiusura della connessione, viene emesso un FIN dal server che riceverà - un ACK dal client, a questo punto la connessione è conclusa e il client - resta nello stato \texttt{TIME\_WAIT}. -\end{enumerate} - - -\subsection{La gestione dei processi figli} -\label{sec:TCP_child_hand} - -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} - -Dato che non è il caso di lasciare processi zombie\index{zombie}, occorrerà -ricevere opportunamente lo stato di terminazione del processo (si veda -\secref{sec:proc_wait}), cosa che faremo utilizzando \const{SIGCHLD} secondo -quanto illustrato in \secref{sec:sig_sigchld}. Una prima modifica al nostro -server è pertanto quella di inserire la gestione della terminazione dei -processi figli attraverso l'uso di un gestore. Per questo useremo la funzione -\code{Signal} (che abbiamo illustrato in \figref{fig:sig_Signal_code}), per -installare il gestore che riceve i segnali dei processi figli terminati già -visto in \figref{fig:sig_sigchld_handl}. Basterà allora aggiungere il -seguente codice: \includecodesnip{listati/sigchildhand.c} -\noindent -all'esempio illustrato in \figref{fig:TCP_echo_server_first_code}. - -In questo modo però si introduce un altro problema. Si ricordi infatti che, -come spiegato in \secref{sec:sig_gen_beha}, quando un programma si trova in -stato di \texttt{sleep} durante l'esecuzione di una system call, questa viene -interrotta alla ricezione di un segnale. Per questo motivo, alla fine -dell'esecuzione del gestore del segnale, se questo ritorna, il programma -riprenderà l'esecuzione ritornando dalla system call interrotta con un errore -di \errcode{EINTR}. - -Vediamo allora cosa comporta tutto questo nel nostro caso: quando si chiude il -client, il processo figlio che gestisce la connessione terminerà, ed il padre, -per evitare la creazione di zombie, riceverà il segnale \const{SIGCHLD} -eseguendo il relativo gestore. Al ritorno del gestore però l'esecuzione nel -padre ripartirà subito con il ritorno della funzione \func{accept} (a meno di -un caso fortuito in cui il segnale arriva durante l'esecuzione del programma -in risposta ad una connessione) con un errore di \errcode{EINTR}. Non avendo -previsto questa eventualità il programma considera questo un errore fatale -terminando a sua volta con un messaggio del tipo: -\begin{verbatim} -[root@gont sources]# ./echod -i -accept error: Interrupted system call -\end{verbatim}%# - -Come accennato in \secref{sec:sig_gen_beha} le conseguenze di questo -comportamento delle system call possono essere superate in due modi diversi, -il più semplice è quello di modificare il codice di \func{Signal} per -richiedere il riavvio automatico delle system call interrotte secondo la -semantica di BSD, usando l'opzione \const{SA\_RESTART} di \func{sigaction}; -rispetto a quanto visto in \figref{fig:sig_Signal_code}. Definiremo allora la -nuova funzione \func{SignalRestart}\footnote{anche questa è definita, insieme - alle altre funzioni riguardanti la gestione dei segnali, nel file - \file{SigHand.c}, il cui contento completo può essere trovato negli esempi - allegati.} come mostrato in \figref{fig:sig_SignalRestart_code}, ed -installeremo il gestore usando quest'ultima. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/SignalRestart.c} - \end{minipage} - \normalsize - \caption{La funzione \funcd{SignalRestart}, che installa un gestore di - segnali in semantica BSD per il riavvio automatico delle system call - interrotte.} - \label{fig:sig_SignalRestart_code} -\end{figure} - -Come si può notare questa funzione è identica alla precedente \func{Signal}, -illustrata in \figref{fig:sig_Signal_code}, solo che in questo caso invece di -inizializzare a zero il campo \var{sa\_flags} di \struct{sigaction}, lo si -inizializza (\texttt{\small 5}) al valore \const{SA\_RESTART}. Usando questa -funzione al posto di \func{Signal} nel server non è necessaria nessuna altra -modifica: le system call interrotte saranno automaticamente riavviate, e -l'errore \errcode{EINTR} non si manifesterà più. - -La seconda soluzione è più invasiva e richiede di controllare tutte le volte -l'errore restituito dalle varie system call, ripetendo la chiamata qualora -questo corrisponda ad \errcode{EINTR}. Questa soluzione ha però il pregio -della portabilità, infatti lo standard POSIX dice che la funzionalità di -riavvio automatico delle system call, fornita da \const{SA\_RESTART}, è -opzionale, per cui non è detto che essa sia disponibile su qualunque sistema. -Inoltre in certi casi,\footnote{Stevens in \cite{UNP1} accenna che la maggior - parte degli Unix derivati da BSD non fanno ripartire \func{select}; altri - non riavviano neanche \func{accept} e \func{recvfrom}, cosa che invece nel - caso di Linux viene sempre fatta.} anche quando questa è presente, non è -detto possa essere usata con \func{accept}. - - -La portabilità nella gestione dei segnali però viene al costo di una -riscrittura parziale del server, la nuova versione di questo, in cui si sono -introdotte una serie di nuove opzioni che ci saranno utili per il debug, è -mostrata in \figref{fig:TCP_echo_server_code_second}, dove si sono riportate -la sezioni di codice modificate nella seconda versione del programma, il -sorgente completo di quest'ultimo si trova nel file -\file{TCP\_echod\_second.c} dei sorgenti allegati alla guida. - -La prima modifica effettuata è stata quella di introdurre una nuova opzione a -riga di comando, \texttt{-c}, che permette di richiedere il comportamento -compatibile nella gestione di \const{SIGCHLD} al posto della semantica BSD -impostando la variabile \var{compat} ad un valore non nullo. Questa è -preimpostata al valore nullo, cosicché se non si usa questa opzione il -comportamento di default del server è di usare la semantica BSD. - -Una seconda opzione aggiunta è quella di inserire un tempo di attesa fisso -specificato in secondi fra il ritorno della funzione \func{listen} e la -chiamata di \func{accept}, specificabile con l'opzione \texttt{-w}, che -permette di impostare la variabile \var{waiting}. Infine si è introdotta una -opzione \texttt{-d} per abilitare il debugging che imposta ad un valore non -nullo la variabile \var{debugging}. Al solito si è omessa da -\figref{fig:TCP_echo_server_code_second} la sezione di codice relativa alla -gestione di tutte queste opzioni, che può essere trovata nel sorgente del -programma. - -\begin{figure}[!htb] - \footnotesize \centering - \begin{minipage}[c]{15.6cm} - \includecodesample{listati/TCP_echod_second.c} - \end{minipage} - \normalsize - \caption{La sezione nel codice della seconda versione del server - per il servizio \textit{echo} modificata per tener conto dell'interruzione - delle system call.} - \label{fig:TCP_echo_server_code_second} -\end{figure} - -Vediamo allora come è cambiato il nostro server; una volta definite le -variabili e trattate le opzioni il primo passo (\texttt{\small 9--13}) è -verificare la semantica scelta per la gestione di \const{SIGCHLD}, a seconda -del valore di \var{compat} (\texttt{\small 9}) si installa il gestore con la -funzione \func{Signal} (\texttt{\small 10}) o con \texttt{SignalRestart} -(\texttt{\small 12}), essendo quest'ultimo il valore di default. - -Tutta la sezione seguente, che crea il socket, cede i privilegi di -amministratore ed eventualmente lancia il programma come demone, è rimasta -invariata e pertanto è stata omessa in -\figref{fig:TCP_echo_server_code_second}; l'unica modifica effettuata prima -dell'entrata nel ciclo principale è stata quella di aver introdotto, subito -dopo la chiamata (\texttt{\small 17--20}) alla funzione \func{listen}, una -eventuale pausa con una condizione (\texttt{\small 21}) sulla variabile -\var{waiting}, che viene inizializzata, con l'opzione \code{-w Nsec}, al -numero di secondi da aspettare (il valore preimpostato è nullo). - -Si è potuto lasciare inalterata tutta la sezione di creazione del socket -perché nel server l'unica chiamata ad una system call critica, che può essere -interrotta dall'arrivo di \const{SIGCHLD}, è quella ad \func{accept}, che è -l'unica funzione che può mettere il processo padre in stato di sleep nel -periodo in cui un figlio può terminare; si noti infatti come le altre -\textit{slow system call}\footnote{si ricordi la distinzione fatta in - \secref{sec:sig_gen_beha}.} o sono chiamate prima di entrare nel ciclo -principale, quando ancora non esistono processi figli, o sono chiamate dai -figli stessi e non risentono di \const{SIGCHLD}. - -Per questo l'unica modifica sostanziale nel ciclo principale (\texttt{\small - 23--42}), rispetto precedente versione di \figref{fig:TCP_ServEcho_first}, è -nella sezione (\texttt{\small 26--30}) in cui si effettua la chiamata di -\func{accept}. Quest'ultima viene effettuata (\texttt{\small 26--27}) -all'interno di un ciclo di \code{while}\footnote{la sintassi del C relativa a - questo ciclo può non essere del tutto chiara. In questo caso infatti si è - usato un ciclo vuoto che non esegue nessuna istruzione, in questo modo - quello che viene ripetuto con il ciclo è soltanto il codice che esprime la - condizione all'interno del \code{while}.} che la ripete indefinitamente -qualora in caso di errore il valore di \var{errno} sia \errcode{EINTR}. Negli -altri casi si esce in caso di errore effettivo (\texttt{\small 27--29}), -altrimenti il programma prosegue. - -Si noti che in questa nuova versione si è aggiunta una ulteriore sezione -(\texttt{\small 31--39}) di aiuto per il debug del programma, che eseguita con -un controllo (\texttt{\small 31}) sul valore della variabile \var{debugging} -impostato dall'opzione \texttt{-d}. Qualora questo sia nullo, come -preimpostato, non accade nulla. altrimenti (\texttt{\small 32}) l'indirizzo -ricevuto da \var{accept} viene convertito in una stringa che poi -(\texttt{\small 33--38}) viene opportunamente stampata o sullo schermo o nei -log. - - - - -\section{I vari scenari critici} -\label{sec:TCP_echo_critical} - -Con le modifiche viste in \secref{sec:TCP_child_hand} il nostro esempio -diventa in grado di affrontare la gestione ordinaria delle connessioni, ma un -server di rete deve tenere conto che, al contrario di quanto avviene per i -server che operano nei confronti di processi presenti sulla stessa macchina, -la rete è di sua natura inaffidabile, per cui è necessario essere in grado di -gestire tutta una serie di situazioni critiche che non esistono per i processi -locali. - - -\subsection{La terminazione precoce della connessione} -\label{sec:TCP_conn_early_abort} - -La prima situazione critica è quella della terminazione precoce, causata da un -qualche errore sulla rete, della connessione effettuata da un client. Come -accennato in \secref{sec:TCP_func_accept} la funzione \func{accept} riporta -tutti gli eventuali errori di rete pendenti su una connessione sul -\textit{connected socket}. Di norma questo non è un problema, in quanto non -appena completata la connessione, \func{accept} ritorna e l'errore sarà -rilevato in seguito, dal processo che gestisce la connessione, alla prima -chiamata di una funzione che opera sul socket. - -È però possibile, dal punto di vista teorico, incorrere anche in uno scenario -del tipo di quello mostrato in \figref{fig:TCP_early_abort}, in cui la -connessione viene abortita sul lato client per un qualche errore di rete con -l'invio di un segmento RST, prima che nel server sia stata chiamata la -funzione \func{accept}. - -\begin{figure}[htb] - \centering - \includegraphics[width=10cm]{img/tcp_client_early_abort} - \caption{Un possibile caso di terminazione precoce della connessione.} - \label{fig:TCP_early_abort} -\end{figure} - -Benché questo non sia un fatto comune, un evento simile può essere osservato -con dei server molto occupati. In tal caso, con una struttura del server -simile a quella del nostro esempio, in cui la gestione delle singole -connessioni è demandata a processi figli, può accadere che il three way -handshake venga completato e la relativa connessione abortita subito dopo, -prima che il padre, per via del carico della macchina, abbia fatto in tempo ad -eseguire la chiamata ad \func{accept}. Di nuovo si ha una situazione analoga -a quella illustrata in \figref{fig:TCP_early_abort}, in cui la connessione -viene stabilita, ma subito dopo si ha una condizione di errore che la chiude -prima che essa sia stata accettata dal programma. - -Questo significa che, oltre alla interruzione da parte di un segnale, che -abbiamo trattato in \secref{sec:TCP_child_hand} nel caso particolare di -\const{SIGCHLD}, si possono ricevere altri errori non fatali all'uscita di -\func{accept}, che come nel caso precedente, necessitano semplicemente la -ripetizione della chiamata senza che si debba uscire dal programma. In questo -caso anche la versione modificata del nostro server non sarebbe adatta, in -quanto uno di questi errori causerebbe la terminazione dello stesso. In Linux -i possibili errori di rete non fatali, riportati sul socket connesso al -ritorno di \func{accept}, sono \errcode{ENETDOWN}, \errcode{EPROTO}, -\errcode{ENOPROTOOPT}, \errcode{EHOSTDOWN}, \errcode{ENONET}, -\errcode{EHOSTUNREACH}, \errcode{EOPNOTSUPP} e \errcode{ENETUNREACH}. - -Si tenga presente che questo tipo di terminazione non è riproducibile -terminando il client prima della chiamata ad \func{accept}, come si potrebbe -fare usando l'opzione \texttt{-w} per introdurre una pausa dopo il lancio del -demone, in modo da poter avere il tempo per lanciare e terminare una -connessione usando il programma client. In tal caso infatti, alla terminazione -del client, il socket associato alla connessione viene semplicemente chiuso, -attraverso la sequenza vista in \secref{sec:TCP_conn_term}, per cui la -\func{accept} ritornerà senza errori, e si avrà semplicemente un end-of-file -al primo accesso al socket. Nel caso di Linux inoltre, anche qualora si -modifichi il client per fargli gestire l'invio di un segmento di RST alla -chiusura dal socket (come suggerito da Stevens in \cite{UNP1}), non si ha -nessun errore al ritorno di \funcd{accept} quanto un errore di -\errcode{ECONNRESET} al primo tentativo di accesso al socket. - - - -\subsection{Il crollo del server} -\label{sec:TCP_server_crash} - -Un secondo caso critico è quello in cui si ha il crollo del server. In tal -caso si suppone che il processo del server termini per un errore fatale, cosa -che potremo simulare inviandogli un segnale di terminazione. La conclusione -del processo comporta la chiusura di tutti i file aperti, compresi tutti i -socket relativi a connessioni stabilite; questo significa che al momento del -crollo del servizio il client riceverà un FIN dal server in corrispondenza -della chiusura del socket. - - - - - -%%% Local Variables: -%%% mode: latex -%%% TeX-master: "gapil" -%%% End: