\chapter{Socket TCP elementari}
\label{cha:elem_TCP_sock}
-In questo capitolo inizieremo ad approndire la conoscenza dei socket TCP,
+In questo capitolo iniziamo ad approfondire la conoscenza dei socket TCP,
tratteremo qui dunque il funzionamento delle varie funzioni che si sono usate
nei due esempi elementari forniti in precedenza (vedi
\secref{sec:net_cli_sample} e \secref{sec:net_serv_sample}), previa una
descrizione delle principali caratteristiche del funzionamento di una
connessione TCP.
-La seconda parte del capitolo sarà poi dedicata alla scrittura di una prima
-semplice applicazione client/server completa, che implementi il servizio
-standard \texttt{echo} su TCP.
\section{Il funzionamento di una connessione TCP}
\label{sec:TCPel_connession}
Prima di entrare nei dettagli delle funzioni usate nelle applicazioni che
-utilizzano i socket TCP, è fondamentale spiegare alcune basi del funzionamento
-del TCP, la conoscenza del funzionamento del protocollo è infatti essenziale
+utilizzano i sokcet TCP, è fondamentale spiegare alcune basi del funzionamento
+del TCP; la conoscenza del funzionamento del protocollo è infatti essenziale
per capire il modello di programmazione ed il funzionamento delle API.
-In particolare ci concentreremo sulle modalità con le quali il protocollo da
-inizio e conclude una connessione; faremo anche un breve accenno al
+In particolare ci concentreremo sulle modalità con le quali il protocollo dà
+inizio e conclude una connessione; faremo inoltre anche un breve accenno al
significato di alcuni dei vari stati che il protocollo assume durante la vita
di una connessione, che possono essere osservati per ciascun socket attivo con
l'uso del programma \texttt{netstat}.
-\subsection{La creazione della connessione: il \textit{three way handushake}}
+\subsection{La creazione della connessione: il \textit{three way handshake}}
\label{sec:TCPel_conn_cre}
Il processo che porta a creare una connessione TCP è chiamato \textit{three
- way handushake}; la successione tipica degli eventi (la stessa che si
+ way handshake}; la successione tipica degli eventi (la stessa che si
verifica utilizzando il codice dei due precedenti esempi elementari
\figref{fig:net_cli_code} e \figref{fig:net_serv_code}) che porta alla
creazione di una connessione è la seguente:
che implementa il protocollo) per realizzare la comunicazione, fra questi
dati ci sono una serie di flag usati per gestire la connessione, come
\texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
- come \texttt{SYN} (che sta per \textit{sincronize}) corrispondono a
+ come \texttt{SYN} (che sta per \textit{syncronize}) corrispondono a
funzioni particolari del protocollo e danno il nome al segmento, (per
maggiori dettagli vedere \capref{cha:tcp_protocol})}, in sostanza viene
inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
\begin{figure}[htb]
\centering
-
+ \includegraphics[width=10cm]{img/three_way_handshake.eps}
\caption{Il \textit{three way handshake} del TCP}
\label{fig:TCPel_TWH}
\end{figure}
\item \textit{MSS option} Sta per \textit{maximum segment size}, con questa
opzione ciascun capo della connessione annuncia all'altro il massimo
ammontare di dati che vorrebbe accettare per ciascun segmento nella
- connesione corrente. È possibile leggere e scrivere questo valore attraverso
+ connessione corrente. È possibile leggere e scrivere questo valore attraverso
l'opzione del socket \texttt{TCP\_MAXSEG}.
\item \textit{window scale option} come spiegato in \capref{cha:tcp_protocol} il
protocollo TCP implementa il controllo di flusso attraverso una
\textsl{finestra annunciata} (\textit{advertized window}) con la quale
ciascun capo della comunicazione dichiara quanto spazio disponibile ha in
- memoria per i dati. Questo è un numero a 16 bit dell'haeader, che così può
- indicare un massimo di 65535 bytes (anche se linux usa come massimo 32767
+ memoria per i dati. Questo è un numero a 16 bit dell'header, che così può
+ indicare un massimo di 65535 bytes (anche se Linux usa come massimo 32767
per evitare problemi con alcuni stack bacati che usano l'aritmetica con
segno per implementare lo stack TCP); ma alcuni tipi di connessione come
quelle ad alta velocità (sopra i 45Mbits/sec) e quelle che hanno grandi
protocollo, le ultime due opzioni (trattate nell'RFC 1323) sono meno comuni;
vengono anche dette \textit{long fat pipe options} dato che questo è il nome
che viene dato alle connessioni caratterizzate da alta velocità o da ritardi
-elevati. In ogni caso linux supporta pienamente entrambe le opzioni.
+elevati. In ogni caso Linux supporta pienamente entrambe le opzioni.
\subsection{La terminazione della connessione}
\label{sec:TCPel_conn_term}
Mentre per creare una connessione occorre un interscambio di tre segmenti, la
-procedura di chiusura ne richede quattro; ancora una volta si può fare
+procedura di chiusura ne richiede quattro; ancora una volta si può fare
riferimento al codice degli esempi \figref{fig:net_cli_code} e
\figref{fig:net_serv_code}, in questo caso la successione degli eventi è la
seguente:
\item L'altro capo della connessione riceve il FIN ed esegue la
\textit{chiusura passiva} (da \textit{passive close}); al FIN, come per
tutti i pacchetti, viene risposto con un ACK. Inoltre il ricevimento del FIN
- viene passato al processo che ha aperto il socket come un end of file sulla
+ viene passato al processo che ha aperto il socket come un end-of-file sulla
lettura (dopo che ogni altro eventuale dato rimasto in coda è stato
ricevuto), dato che il ricevimento di un FIN significa che non si
riceveranno altri dati sulla connessione.
con un ACK.
\end{enumerate}
-
Dato che in questo caso sono richiesti un FIN ed un ACK per ciascuna direzione
normalmente i segmenti scambiati sono quattro; normalmente giacché in alcune
-sitazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
+situazioni il FIN del passo 1) è inviato insieme a dei dati. Comunque non è
detto, anche se è possibile, che i segmenti inviati nei passi 2 e 3, siano
accorpati in un singolo segmento. In \nfig\ si è rappresentato graficamente lo
sequenza di scambio dei segmenti che stabilisce la connessione.
\begin{figure}[htb]
- \centering
-
- \caption{Il \textit{three way handshake} del TCP}
- \label{fig:TCPel_TWH}
+ \centering
+ \includegraphics[width=10cm]{img/tcp_close.eps}
+ \caption{La chiusura di una connessione TCP}
+ \label{fig:TCPel_close}
\end{figure}
Come per il SYN anche il FIN occupa un byte nel numero di sequenza, per cui
viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
Infine è da sottolineare che, benché nella figura (e nell'esempio che vedremo
-in \secref{sec:TCPel_echo_example}) sia il client ad eseguire la chiusura
+più avanti in \secref{sec:TCPsimp_echo}) sia il client ad eseguire la chiusura
attiva, nella realtà questa può essere eseguita da uno qualunque dei due capi
della comunicazione (come in fatto in precedenza da
\figref{fig:net_serv_code}), e benché quello del client sia il caso più comune
Una descrizione completa del funzionamento del protocollo va al di là degli
obiettivi di questo libro; un approfondimento sugli aspetti principali si
-trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il miglior
-riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a descrivere
-brevemente un semplice esempio di connessione e le transizioni che avvengono
-nei due casi appena citati (creazione e terminazione della connessione).
+trova in \capref{cha:tcp_protocol}, ma per una trattazione esauriente il
+miglior riferimento resta (FIXME citare lo Stevens); qui ci limiteremo a
+descrivere brevemente un semplice esempio di connessione e le transizioni che
+avvengono nei due casi appena citati (creazione e terminazione della
+connessione).
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
\begin{figure}[htb]
\centering
-
+ \includegraphics[width=9cm]{img/tcp_connection.eps}
\caption{Schema dello scambio di pacchetti per un esempio di connessione}
\label{fig:TPCel_conn_example}
\end{figure}
La connessione viene iniziata dal client che annuncia un MSS di 1460 (un
-valore tipico per IPv4 su ethernet) con linux, il server risponde con lo
+valore tipico per IPv4 su ethernet) con Linux, 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
risposta.
Infine si ha lo scambio dei quattro segmenti che terminano la connessione
-secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo della
-connessione che esegue la chiusura attiva entra nello stato
+secondo quanto visto in \secref{sec:TCPel_conn_term}; si noti che il capo
+della connessione che esegue la chiusura attiva entra nello stato
\texttt{TIME\_WAIT} su cui torneremo fra poco.
È da notare come per effettuare uno scambio di due pacchetti (uno di richiesta
più di MSL secondi.
Ogni implementazione del TCP deve scegliere un valore per la MSL (l'RFC1122
-raccomanda 2 minuti, linux usa 30 secondi), questo comporta una durata dello
+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.
Il primo dei due motivi precedenti si può capire tornando a \curfig: assumendo
che l'ultimo ACK della sequenza (quello del capo che ha eseguito la chiusura
-attiva) vanga perso, chi esegue la chiusura passiva non ricevndo risposta
+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
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 temo (anche dell'ordine
+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
non ricevendo 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)
-l'anomalia viene a cessare il circolo di instadamento viene spezzato i
+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.
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.
+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
In realtà rispetto a quanto indicato nell'RFC1700 i vari sistemi hanno fatto
scelte diverse per le porte effimere, in particolare in \nfig\ sono riportate
-quelle di BSD, Solaris e linux. Nel caso di linux poi la scelta fra i due
-intervali possibili viene fatta dinamicamente a seconda della memoria a
-disposizione del kernel per gestire le rative tabelle.
+quelle di BSD, Solaris e Linux. Nel caso di Linux poi la scelta fra i due
+intervalli possibili viene fatta dinamicamente a seconda della memoria a
+disposizione del kernel per gestire le relative tabelle.
\begin{figure}[!htb]
\centering
-
+ \includegraphics[width=10cm]{img/tcpip_overview.eps}
\caption{Allocazione dei numeri di porta}
\label{fig:TCPel_port_alloc}
\end{figure}
corrispondono alle porte con numero minore di 1024 e coincidono quindi con le
porte conosciute). La loro caratteristica è che possono essere assegnate a un
socket solo da un processo con i privilegi di root, per far si che solo
-l'amministratore possa allocare queste porte per far partire relativi servizi.
+l'amministratore possa allocare queste porte per far partire i relativi
+servizi.
Si tenga conto poi che ci sono alcuni client (in particolare \texttt{rsh} e
\texttt{rlogin}) che richiedono una connessione su una porta riservata anche
Per capire meglio l'uso delle porte e come vengono utilizzate quando si ha a
che fare con un'applicazione client/server (come quella che scriveremo in
-\secref{sec:TCPel_echo_example}) esaminaremo cosa accade con le connessioni nel
+\secref{sec:TCPel_cunc_serv}) esamineremo cosa accade con le connessioni nel
caso di un server TCP che deve gestire connessioni multiple.
-Se esguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
+Se eseguiamo un \texttt{netstat} su una macchina di prova (che supponiamo avere
indirizzo 195.110.112.152) potremo avere un risultato del tipo:
\begin{verbatim}
Active Internet connections (servers and established)
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 interfaccie locali; la notazione 0.0.0.0 usata da netstat è
+associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
equivalente all'asterisco utilizzato per il numero di porta ed indica il
valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
\texttt{arpa/inet.h}.
Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
specificati; in questo caso la \textit{socket pair} associata al socket può
-essere indicata come $(*:22, *.*)$, usando l'asterisco anche per gli indirizzi
+essere indicata come $(*:22, *:*)$, usando l'asterisco anche per gli indirizzi
come carattere di \textit{wildchard}.
In genere avendo le macchine associato un solo IP ci si può chiedere che senso
abbia l'utilizzo dell'indirizzo generico per l'indirizzo locale, ma esistono
anche macchine che hanno più di un indirizzo IP (il cosiddetto
-\textit{miltihoming}) in questo modo si possono accettare connessioni
+\textit{multihoming}) in questo modo si possono accettare connessioni
indirizzate verso uno qualunque di essi. Ma come si può vedere nell'esempio
con il DNS in ascolto sulla porta 53 è anche possibile restringere l'accesso
solo alle connessioni che provengono da uno specifico indirizzo, cosa che nel
Una volta che ci si vorrà collegare a questa macchina da un'altra posta
all'indirizzo 192.84.146.100 si potrà lanciare un client \texttt{ssh} per
-creare una connessione verso la precedente, e il kernel associerà al suddetto
+creare una connessione verso la precedente, e il kernel assocerà al suddetto
una porta effimera che per esempio potrà essere la 21100, la connessione
allora sarà espressa dalla socket pair $(192.84.146.100:21100,
195.110.112.152.22)$.
sul socket originale.
Se a questo punto lanciamo un'altra volta il client ssh per una seconda
-conessione quello che otterremo usando netstat sarà qualcosa del genere:
+connessione quello che otterremo usando netstat sarà qualcosa del genere:
\begin{verbatim}
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State
\label{fig:TCPel_cliserv_func}
\end{figure}
-Useremo questo schema per l'esempio di implementazione del servizio
-\texttt{echo} che illustreremo in \secref{sec:TCPel_echo_example}.
+Useremo questo schema anche per l'esempio di reimplementazione del servizio
+\texttt{daytime} che illustreremo in \secref{sec:TCPel_cunc_serv}.
\subsection{La funzione \texttt{bind}}
di errore. La variabile \texttt{errno} viene settata secondo i seguenti
codici di errore:
\begin{errlist}
- \item \texttt{EBADF} Il file descriptor non è valido.
- \item \texttt{EINVAL} Il socket ha già un indirizzo assegnato.
- \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
- \item \texttt{EACCESS} Si è cercato di usare un indirizzo riservato senza
+ \item \texttt{EBADF} il file descriptor non è valido.
+ \item \texttt{EINVAL} il socket ha già un indirizzo assegnato.
+ \item \texttt{ENOTSOCK} il file descriptor non è associato ad un socket.
+ \item \texttt{EACCESS} si è cercato di usare un indirizzo riservato senza
essere root.
\end{errlist}
\end{prototype}
alle connessioni che arrivano verso tale indirizzo.
Normalmente un client non specifica mai un indirizzo ad un suo socket, ed il
-kernel sceglie l'indirizzo di orgine quando viene effettuata la connessione
+kernel sceglie l'indirizzo di origine quando viene effettuata la connessione
sulla base dell'interfaccia usata per trasmettere i pacchetti, (che dipende
dalle regole di instradamento usate per raggiungere il server).
Se un server non specifica il suo indirizzo locale il kernel userà come
Per specificare un indirizzo generico con IPv4 si usa il valore
\texttt{INADDR\_ANY}, il cui valore, come visto anche negli esempi precedenti
-è pari a zero, nell'esempio \figref{fig:net_serv_sample} si è usata
+è pari a zero, nell'esempio \figref{fig:net_serv_code} si è usata
un'assegnazione immediata del tipo:
\begin{verbatim}
serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
Si noti che si è usato \texttt{htonl} per assegnare il valore
\texttt{INADDR\_ANY}; benché essendo questo pari a zero il riordinamento sia
-inutile; ma dato che tutte le constanti \texttt{INADDR\_} sono definite
+inutile; ma dato che tutte le costanti \texttt{INADDR\_} sono definite
secondo l'ordinamento della macchina è buona norma usare sempre la funzione
\texttt{htonl}.
connessione con un server TCP, il prototipo della funzione è il seguente:
\begin{prototype}{sys/socket.h}
-{int connect(int sockfd, const struct sockaddr *serv\_addr, socklen\_t addrlen)}
+{int connect(int sockfd, const struct sockaddr *servaddr, socklen\_t addrlen)}
Il primo argomento è un file descriptor ottenuto da una precedente chiamata
a \texttt{socket}, mentre il secondo e terzo argomento sono rispettivamente
di errore. La variabile \texttt{errno} viene settata secondo i seguenti
codici di errore:
\begin{errlist}
- \item \texttt{EBADF} Il file descriptor non è valido.
- \item \texttt{EFAULT} L'indirizzo della struttura di indirizzi è al di fuori
+ \item \texttt{EBADF} il file descriptor non è valido.
+ \item \texttt{EFAULT} l'indirizzo della struttura di indirizzi è al di fuori
dello spazio di indirizzi dell'utente.
- \item \texttt{ENOTSOCK} Il file descriptor non è associato ad un socket.
- \item \texttt{EISCONN} Il socket è già connesso.
- \item \texttt{ECONNREFUSED} Non c'è nessuno in ascolto sull'indirizzo remoto.
- \item \texttt{ETIMEDOUT} Si è avuto timeout durante il tentativo di
+ \item \texttt{ENOTSOCK} il file descriptor non è associato ad un socket.
+ \item \texttt{EISCONN} il socket è già connesso.
+ \item \texttt{ECONNREFUSED} non c'è nessuno in ascolto sull'indirizzo remoto.
+ \item \texttt{ETIMEDOUT} si è avuto timeout durante il tentativo di
connessione.
- \item \texttt{ENETUNREACH} La rete non è raggiungibile.
- \item \texttt{EADDRINUSE} L'indirizzo locale è in uso.
- \item \texttt{EINPROGRESS} Il socket è non bloccante e la connessione non
+ \item \texttt{ENETUNREACH} la rete non è raggiungibile.
+ \item \texttt{EADDRINUSE} l'indirizzo locale è in uso.
+ \item \texttt{EINPROGRESS} il socket è non bloccante e la connessione non
può essere conclusa immediatamente.
- \item \texttt{EALREADY} Il socket è non bloccante e un tentativo precedente
+ \item \texttt{EALREADY} il socket è non bloccante e un tentativo precedente
di connessione non si è ancora concluso.
- \item \texttt{EAGAIN} Non ci sono più porte locali libere.
- \item \texttt{EAFNOSUPPORT} L'indirizzo non ha una famiglia di indirizzi
+ \item \texttt{EAGAIN} non ci sono più porte locali libere.
+ \item \texttt{EAFNOSUPPORT} l'indirizzo non ha una famiglia di indirizzi
corretta nel relativo campo.
- \item \texttt{EACCESS, EPERM} Si è tentato di eseguire una connessione ad un
- indirizzo broacast senza che il socket fosse stato abilitato per il
+ \item \texttt{EACCESS, EPERM} si è tentato di eseguire una connessione ad un
+ indirizzo broadcast senza che il socket fosse stato abilitato per il
broadcast.
\end{errlist}
\end{prototype}
dopo circa 180 secondi.
%
% Le informazioni su tutte le opzioni settabili via /proc stanno in
-% linux/Documentation/networking/ip-sysctl.txt
+% 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 probablmente che o si è sbagliato il numero della porta o che
+ 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
\texttt{ECONNREFUSED}.
Il flag RST sta per \textit{reset} ed è un segmento inviato direttamente
dal TCP quando qualcosa non va. Tre condizioni che generano un RST sono:
quando arriva un SYN per una porta che non ha nessun server in ascolto,
- quando il TCP abortisce una connessione in corso, quandi TCP riceve un
+ 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'emmissione dei SYN
+ 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
\texttt{ENETUNREACH}.
Si noti infine che con la funzione \texttt{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à contentente indirizzo e porta
+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 \texttt{bind}.
La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
codici di errore restituiti in \texttt{errno} sono i seguenti:
\begin{errlist}
- \item \texttt{EBADF} L'argomento \texttt{sockfd} non è un file descriptor
+ \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
valido.
- \item \texttt{ENOTSOCK} L'argomento \texttt{sockfd} non è un socket.
- \item \texttt{EOPNOTSUPP} Il socket è di un tipo che non supporta questa
+ \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
+ \item \texttt{EOPNOTSUPP} il socket è di un tipo che non supporta questa
operazione.
\end{errlist}
\end{prototype}
infatti vengono mantenute due code:
\begin{enumerate}
\item Una coda delle connessioni incomplete (\textit{incomplete connection
- queue} che contiene una entrata per ciascun SYN arrivato per il quale si
- sta attendendo la conclusione del three-way handshake. Questi socket sono
- tutti nello stato \texttt{SYN\_RECV}.
+ queue} che contiene un ingresso per ciascun socket per il quale è arrivato
+ un SYN ma il three way handshake non si è ancora concluso. Questi socket
+ sono tutti nello stato \texttt{SYN\_RECV}.
\item Una coda delle connessioni complete (\textit{complete connection queue}
- che contiene una entrata per ciascuna connessione per le quali il three-way
+ che contiene un ingresso per ciascun socket per il quale il three way
handshake è stato completato ma ancora \texttt{accept} non è ritornata.
+ Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
\end{enumerate}
Lo schema di funzionamento è descritto in \nfig, quando arriva un SYN da un
client il server crea una nuova entrata nella coda delle connessioni
incomplete, e poi risponde con il SYN$+$ACK. La entrata resterà nella coda
delle connessioni incomplete fino al ricevimento dell'ACK dal client o fino ad
-un timeout. Nel caso di completamento del three-way handshake l'entrata viene
+un timeout. Nel caso di completamento del three way handshake l'entrata viene
sostata nella coda delle connessioni complete. Quando il processo chiama la
funzione \texttt{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
entrata nella coda delle connessioni complete è passata al programma, o, se la
massimo valore della somma del numero di entrate possibili per ciascuna di
dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
valore, e provvede una tabella con i risultati ottenuti con vari kernel,
-compreso linux 2.0, che mostrano le differenze fra diverse implementazioni.
+compreso Linux 2.0, che mostrano le differenze fra diverse implementazioni.
-Ma in linux il significato di questo valore è cambiato a partire dal kernel
+In Linux il significato di questo valore è cambiato a partire dal kernel
2.2 per prevenire l'attacco chiamato \texttt{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
+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 la coda delle connessioni incomplete viene saturata, impedendo di
-fatto le connessioni.
+perduti e la coda delle connessioni incomplete viene saturata, impedendo di
+fatto ulteriori connessioni.
Per ovviare a questo il significato del \texttt{backlog} è stato cambiato a
-significare la lunghezza della coda delle connessioni complete. La lunghezza
+indicare la lunghezza della coda delle connessioni complete. La lunghezza
della coda delle connessioni incomplete può essere ancora controllata usando
la \texttt{sysctl} o scrivendola direttamente in
\texttt{/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 \texttt{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
-viene ignorato e non esiste più un valore massimo.
+viene ignorato e non esiste più un valore massimo. In ogni caso in Linux il
+valore di \texttt{backlog} viene troncato ad un massimo di \texttt{SOMAXCONN}
+se è superiore a detta costante (che di default vale 128).
La scelta storica per il valore di questo parametro è di 5, e alcuni vecchi
kernel non supportavano neanche valori superiori, ma la situazione corrente è
-molto cambiata dagli anni '80 e con server web che possono sopportare diversi
-milioni di connessioni al giorno un tale valore non è più adeguato. Non esiste
+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 specificare questo valore con una costante (il cui cambiamento
-richiederebbe la ricompilazione del server) ma usare piuttosto una variabile
-di ambiente (vedi \secref{sec:xxx_env_var}). Lo Stevens tratta accuratamente
-questo argomento, con esempi presi da casi reali su web server, ed in
-particolare evidenzia come non sia più vero che la ragione della coda è quella
-di gestire il caso in cui il server è occupato fra chiamate successive alla
-\texttt{accept} (per cui la coda più occupata sarebbe quella delle connessioni
-compeltate), ma è invece necessaria a gestire la presenza di un gran numero di
-SYN in attesa di completare il three-way handshake.
-
-Come accennato nel caso del TCP se un SYN arriva con tutte le code piene, il
-pacchetto sarà ignorato. Questo viene fatto perché la condizione delle code
-piene è transitoria, e se il client ristrasmette il SYN è probabile che
-passato un po' di tempo possa trovare lo spazio per una nuova connessione. Se
-invece si rispondesse con un RST la \texttt{connect} del client ritornerebbe
-con una condizione di errore, mentre questo è il tipico caso in cui è si può
-lasciare la gestione della connessione alla ritrasmissione prevista dal
-protocollo TCP.
-
+conviene specificarlo con una costante (il cui cambiamento richiederebbe la
+ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi
+\secref{sec:proc_environ}).
+
+Lo Stevens tratta accuratamente questo argomento, con esempi presi da casi
+reali su web server, ed in particolare evidenzia come non sia più vero che il
+compito principale della coda sia quello di gestire il caso in cui il server è
+occupato fra chiamate successive alla \texttt{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 \texttt{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 \texttt{accept}}
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 listen(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
- La funzione estrae la prima connessione completa relativa al socket
- \texttt{sockfd} in attesa sulla coda delle connessioni complete che associa
- nuovo socket con le stesse caratteristiche di \texttt{sockfd} (restituito
- dalla funzione stessa). Il socket originale non viene toccato. Nella
- struttura \texttt{addr} e nella variabile \texttt{addrlen} vengono
- restituiti indirizzo e relativa lunghezza del client che si è connesso.
+{int listen(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
+ La funzione estrae la prima connessione relativa al socket \texttt{sockfd}
+ in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
+ con le stesse caratteristiche di \texttt{sockfd} (restituito dalla funzione
+ stessa). Il socket originale non viene toccato. Nella struttura
+ \texttt{addr} e nella variabile \texttt{addrlen} vengono restituiti
+ indirizzo e relativa lunghezza del client che si è connesso.
La funzione restituisce un numero di socket descriptor positivo in caso di
successo e -1 in caso di errore, nel qual caso la variabile \texttt{errno}
viene settata ai seguenti valori:
\begin{errlist}
- \item \texttt{EBADF} L'argomento \texttt{sockfd} non è un file descriptor
+ \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
valido.
- \item \texttt{ENOTSOCK} L'argomento \texttt{sockfd} non è un socket.
- \item \texttt{EOPNOTSUPP} Il socket è di un tipo che non supporta questa
+ \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
+ \item \texttt{EOPNOTSUPP} il socket è di un tipo che non supporta questa
operazione.
- \item \texttt{EAGAIN} or \item \texttt{EWOULDBLOCK} Il socket è stato
+ \item \texttt{EAGAIN} o \item \texttt{EWOULDBLOCK} il socket è stato
settato come non bloccante, e non ci sono connessioni in attesa di essere
accettate.
- \item \texttt{EFAULT} The addr parameter is not in a writable part of the
- user address space.
+ \item \texttt{EFAULT} l'argomento \texttt{addr} .
\item \texttt{EPERM} Firewall rules forbid connection.
\item \texttt{ENOBUFS, ENOMEM} Not enough free memory. This often means
that the memory allocation is limited by the socket buffer limits, not by
the system memory.
+
+ Inoltre possono essere restituiti gli errori di rete relativi al nuovo
+ socket come: \texttt{EMFILE}, \texttt{EINVAL}, \texttt{ENOSR},
+ \texttt{ENOBUFS}, \texttt{EPERM}, \texttt{ECONNABORTED},
+ \texttt{ESOCKTNOSUPPORT}, \texttt{EPROTONOSUPPORT}, \texttt{ETIMEDOUT},
+ \texttt{ERESTARTSYS}.
+
\end{errlist}
\end{prototype}
La funzione può essere usata solo con socket che supportino la connessione
(cioè di tipo \texttt{SOCK\_STREAM}, \texttt{SOCK\_SEQPACKET} o
\texttt{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
-esplicita della connessione, (attualmenente in linux solo DECnet ha questo
+esplicita della connessione, (attualmente in Linux solo DECnet ha questo
comportamento), la funzione opera solo l'estrazione dalla coda delle
connessioni, la conferma della connessione viene fatta implicitamente dalla
prima chiamata ad una \texttt{read} o una \texttt{write} mentre il rifiuto
-della connessione viene fatta con la funzione \texttt{close}.
+della connessione viene fatto con la funzione \texttt{close}.
-I due parametri \texttt{cliaddr} e \texttt{addrlen} (si noti che quest'ultimo
+È da chiarire che Linux presenta un comportamento diverso nella gestione degli
+errori rispetto ad altre implementazioni dei socket BSD, infatti la funzione
+\texttt{accept} passa gli errori di rete pendenti sul nuovo socket come codici
+di errore per \texttt{accept}. Inoltre la funzione non fa ereditare ai nuovi
+socket flag come \texttt{O\_NONBLOCK}, che devono essere rispecificati volta
+volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
+deve essere tenuto in conto per scrivere programmi portabili.
+
+I due argomenti \texttt{cliaddr} e \texttt{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
\texttt{addrlen} deve essere inizializzato alle dimensioni della struttura il
-cui indirizzo è passato come parametro in \texttt{cliaddr}, al rientro della
+cui indirizzo è passato come argomento in \texttt{cliaddr}, al ritorno della
funzione \texttt{addrlen} conterrà il numero di bytes scritti dentro
-\texttt{cliaddr}.
+\texttt{cliaddr}. Se questa informazione non interessa basterà inizializzare a
+\texttt{NULL} detti puntatori.
+
+Se la funzione ha successo restituisce il descrittore di un nuovo socket
+creato dal kernel (detto \textit{connected socket}) a cui viene associata la
+prima connessione completa (estratta dalla relativa coda, vedi
+\secref{sec:TCPel_func_listen}) che il client TCP ha effettuato verso il
+socket \texttt{sockfd}. Quest'ultimo (detto \textit{listening socket}) è
+quello creato all'inizio e messo in ascolto con \texttt{listen}, e non viene
+toccato dalla funzione.
+Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
+il processo\footnote{a meno che non si sia settato il socket per essere
+ non-bloccante, nel qual caso ritorna con l'errore \texttt{EAGAIN},
+ torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
+fintanto che non ne arriva una.
+
+Il meccanismo di funzionamento di \texttt{accept} è essenziale per capire il
+funzionamento di un server: in generale infatti c'è sempre un solo socket in
+ascolto, che resta per tutto il tempo nello stato \texttt{LISTEN}, mentre le
+connessioni vengono gestite dai nuovi socket ritornati da \texttt{accept} che
+si trovano automaticamente nello stato \texttt{ESTABLISHED} e utilizzati fino
+alla chiusura della connessione che avviene su di essi. Si può riconoscere
+questo schema anche nell'esempio elementare in \figref{fig:net_serv_code} dove
+per ogni connessione il socket creato da \texttt{accept} viene chiuso dopo
+l'invio dei dati.
+
+
+\subsection{La funzione \texttt{close}}
+\label{sec:TCPel_func_close}
+
+La funzione standard unix \texttt{close} (vedi \secref{sec:fileunix_close})
+che si usa sui file può essere usata con lo stesso effetto anche sui socket
+descriptor.
+
+L'azione standard di questa funzione quando applicata a socket è di marcarlo
+come chiuso e ritornare immediatamente al processo. Una volta chiamata il
+socket descriptor non è più utilizzabile dal processo e non può essere usato
+come argomento per una \texttt{write} o una \texttt{read} (anche se l'altro
+capo della connessione non avesse chiuso la sua parte). Il kernel invierà
+comunque tutti i dati che ha in coda prima di iniziare la sequenza di chiusura.
+
+Vedremo più avanti in \secref{sec:TCPadv_so_linger} come è possibile cambiare
+questo comportamento, e cosa deve essere fatto perché il processo possa
+assicurarsi che l'altro capo abbia ricevuto tutti i dati.
+
+Come per i file anche per i socket descriptor viene mantenuto un numero di
+riferimenti, per cui se più di un processo ha lo stesso socket aperto
+l'emissione del FIN e la sequenza di chiusura di TCP non viene innescata
+fintanto che il numero di riferimenti non si annulla. Questo è il
+comportamento normale che ci si aspetta in un'applicazione client/server quale
+quella che illustreremo in \secref{sec:TCPel_cunc_serv}.
+
+Per attivare immediatamente l'emissione del FIN e la sequenza di chiusura si
+può usare la funzione \texttt{shutdown} su cui torneremo in seguito.
+
+
+\section{I server concorrenti su TCP}
+\label{sec:TCPel_cunc_serv}
+
+Il server \texttt{daytime} dell'esempio in \secref{sec:net_cli_sample} è un
+tipico esempio di server iterativo, in cui viene servita una richiesta alla
+volta; in generale però, specie se il servizio è più complesso e comporta uno
+scambio di dati più sostanzioso di quello in questione, non è opportuno
+bloccare un server nel servizio di un client per volta; per questo si ricorre
+alle capacità di multitasking del sistema.
+
+Il modo più immediato per creare un server concorrente è allora quello di
+usare la funzione \texttt{fork} per far creare al server per ogni richiesta da
+parte di un client un processo figlio che si incarichi della gestione della
+comunicazione.
+
+
+\subsection{Un esempio di server \textit{daytime} concorrente}
+\label{sec:TCPel_cunc_daytime}
+
+Per illustrare il meccanismo usato in generale per creare un server
+concorrente abbiamo riscritto il server \texttt{daytime} dell'esempio
+precedente in forma concorrente, inserendo anche una opzione per la stampa
+degli indirizzi delle connessioni ricevute.
+
+In \nfig\ è mostrato un estratto del codice, in cui si sono tralasciati il
+trattamento delle opzioni e le parti rimaste invariate rispetto al precedente
+esempio. Al solito il sorgente completo del server
+\texttt{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti.
+
+\begin{figure}[!htb]
+ \footnotesize
+ \begin{lstlisting}{}
+#include <sys/types.h> /* predefined types */
+#include <unistd.h> /* include unix standard library */
+#include <arpa/inet.h> /* IP addresses conversion utiliites */
+#include <sys/socket.h> /* socket library */
+#include <stdio.h> /* include standard I/O library */
+#include <time.h>
+
+int main(int argc, char *argv[])
+{
+ int list_fd, conn_fd;
+ int i;
+ struct sockaddr_in serv_add, client;
+ char buffer[MAXLINE];
+ socklen_t len;
+ time_t timeval;
+ pid_t pid;
+ int logging=0;
+ ...
+ /* write daytime to client */
+ while (1) {
+ if ( (conn_fd = accept(list_fd, (struct sockaddr *)&client, &len))
+ <0 ) {
+ perror("accept error");
+ exit(-1);
+ }
+ /* fork to handle connection */
+ if ( (pid = fork()) < 0 ){
+ perror("fork error");
+ exit(-1);
+ }
+ if (pid == 0) { /* child */
+ close(list_fd);
+ timeval = time(NULL);
+ snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
+ if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
+ perror("write error");
+ exit(-1);
+ }
+ if (logging) {
+ inet_ntop(AF_INET, &client.sin_addr, buffer, sizeof(buffer));
+ printf("Request from host %s, port %d\n", buffer,
+ ntohs(client.sin_port));
+ }
+ close(conn_fd);
+ exit(0);
+ } else { /* parent */
+ close(conn_fd);
+ }
+ }
+ /* normal exit, never reached */
+ exit(0);
+}
+ \end{lstlisting}
+ \caption{Esempio di codice di un server concorrente elementare per il
+ servizio daytime.}
+ \label{fig:TCPel_serv_code}
+\end{figure}
+
+Come si può vedere (alle linee \texttt{\small 21--25}) la funzione
+\texttt{accept} stavolta è chiamata fornendo una struttura di indirizzi in cui
+saranno ritornati numero IP e porta da cui il client effettua la connessione,
+che stamperemo, se avremo abilitato il logging, sullo standard output
+(\texttt{\small 39--43}).
+
+Quando \texttt{accept} ritorna il server chiama la funzione \texttt{fork}
+(\texttt{\small 26--30}) per creare il processo figlio che effettuerà tutte le
+operazioni relative a quella connessione (\texttt{\small 31--45}), mentre il
+padre resterà in attesa di ulteriori connessioni.
+
+Si noti come il figlio operi solo sul socket connesso, chiudendo
+immediatamente il socket \texttt{list\_fd}; mentre il padre continua ad
+operare solo sul socket in ascolto chiudendo \texttt{sock\_fd} dopo ciascuna
+\texttt{accept}. Per quanto abbiamo detto in \secref{sec:TCPel_func_close}
+queste due chiusure non causano l'innesco della sequenza di chiusura perché il
+numero di riferimenti non si è annullato.
+
+Infatti subito dopo la creazione del socket \texttt{list\_fd} ha una
+referenza, e lo stesso vale per \texttt{sock\_fd} dopo il ritorno di
+\texttt{accept}, ma dopo la fork i descrittori vengono duplicati nel padre e
+nel figlio per cui entrambi i socket si trovano con due referenze. Questo fa
+si che quando il padre chiude \texttt{sock\_fd} esso resta con una referenza
+da parte del figlio, e sarà definitivamente chiuso solo quando quest'ultimo,
+dopo aver completato le sue operazioni, chiamerà la funzione \texttt{close}.
+
+In realtà per il figlio non sarebbero necessarie nessuna delle due chiamate a
+\texttt{close} in quanto nella \texttt{exit} tutti i file ed i socket vengono
+chiusi, ma si è preferito effettuare la chiusura esplicitamente per avere una
+maggiore chiarezza del codice ed evitare possibili errori.
+
+Si noti come sia essenziale che il padre chiuda ogni volta il socket connesso
+dopo la \texttt{accept}; se così non fosse nessuno di questi socket sarebbe
+effettivamente chiuso dato che alla chiusura da parte del figlio resterebbe
+ancora un riferimento. Si avrebbero così due effetti, il padre potrebbe
+esaurire i descrittori disponibili (che sono un numero limitato per ogni
+processo) e soprattutto nessuna delle connessioni con i client verrebbe
+chiusa.
+
+
+\subsection{Le funzioni \texttt{getsockname} e \texttt{getpeername}}
+\label{sec:TCPel_get_names}
+
+Queste due funzioni vengono usate per ottenere la socket pair associata ad un
+certo socket; la prima restituisce l'indirizzo locale, la seconda quello
+remoto.
-Se la funzione ha successo restituisce un nuovo socket descriptor, detto
-\textit{connected socket}, su cui è agganciata la connessione che il client
-TCP ha effettuato verso il socket \texttt{sockfd}. Quest'ultimo, che viene
-chiamato invece \textit{listening socket}, deve essere stato creato in
-precedenza e messo in ascolto con \texttt{listen}, e non viene toccato dalla
-funzione.
+\begin{prototype}{sys/socket.h}
+{int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+
+ La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
+ codici di errore restituiti in \texttt{errno} sono i seguenti:
+ \begin{errlist}
+ \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
+ valido.
+ \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
+ \item \texttt{ENOBUFS} non ci sono risorse sufficienti nel sistema per
+ eseguire l'operazione.
+ \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
+ spazio di indirizzi del processo.
+ \end{errlist}
+\end{prototype}
+
+La funzione \texttt{getsockname} si usa tutte le volte che si vuole avere
+l'indirizzo locale di un socket; ad esempio può essere usata da un client (che
+usualmente non chiama \texttt{bind}) per ottenere numero IP e porta locale
+associati al socket restituito da una \texttt{connect}, o da un server che ha
+chiamato \texttt{bind} su un socket usando 0 come porta locale per ottenere il
+numero di porta effimera assegnato dal kernel.
-Questa distinzione è essenziale per capire
+Inoltre quando un server esegue una \texttt{bind} su un indirizzo generico, se
+chiamata dopo il completamento di una connessione sul socket restituito da
+\texttt{accept}, restituisce l'indirizzo locale che il kernel ha assegnato a
+quella connessione.
+\begin{prototype}{sys/socket.h}
+{int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+
+ La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
+ codici di errore restituiti in \texttt{errno} sono i seguenti:
+ \begin{errlist}
+ \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
+ valido.
+ \item \texttt{ENOTSOCK} l'argomento \texttt{sockfd} non è un socket.
+ \item \texttt{ENOTCONN} il socket non è connesso.
+ \item \texttt{ENOBUFS} non ci sono risorse sufficienti nel sistema per
+ eseguire l'operazione.
+ \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
+ spazio di indirizzi del processo.
+ \end{errlist}
+\end{prototype}
+
-\section{Una semplice implementazione del servizio \texttt{echo} su TCP}
-\label{sec:TCPel_echo_example}
+La funzione \texttt{getpeername} si usa tutte le volte che si vuole avere
+l'indirizzo remoto di un socket.
+
+Ci si può chiedere a cosa serva questa funzione dato che dal lato client
+l'indirizzo remoto è sempre noto quando si esegue la \texttt{connect} mentre
+dal lato server si possono usare, come si è fatto nell'esempio precedente, i
+valori di ritorno di \texttt{accept}.
+
+In generale però questa ultima possibilità è sempre possibile. In particolare
+questo avviene quando il server invece di far gestire la connessione
+direttamente a un processo figlio, come nell'esempio precedente, lancia un
+opportuno programma per ciascuna connessione usando \texttt{exec} (questa ad
+esempio è la modailità con cui opera il \textsl{super-server} \texttt{inetd}
+che gestisce tutta una serie di servizi lanciando per ogni connessione
+l'opportuno 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 \texttt{accept}), all'esecuzione di \texttt{exec} viene caricata
+in memoria l'immagine del programma eseguito che a questo punto perde ogni
+riferimento. Il socket descriptor però resta aperto. Allora se una opportuna
+convenzione è seguita per rendere noto al programma eseguito qual'è il socket
+connesso (\texttt{inetd} ad esempio fa sempre in modo che i file descriptor 0,
+1 e 2 corrispondano al socket connesso) quest'ultimo potrà usare la funzione
+\texttt{getpeername} per determinare l'indirizzo remoto del client.
+
+Infine è da chiarire (si legga la man page) che come per \texttt{accept} il
+terzo parametro che è specificato dallo standard POSIX 1003.1g come di tipo
+\texttt{socklen\_t *} in realtà deve sempre corrispondere ad un \texttt{int *}
+come prima dello standard perché tutte le implementazioni dei socket BSD fanno
+questa assunzione.
-Veniamo ora ad una applicazione
projects / gapil.git / blobdiff