\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
- \texttt{socket}, \texttt{bind} e \texttt{listen}. Completata l'apertura
- passiva il server chiama la funzione \texttt{accept} e il processo si blocca
- in attesa di connessioni.
+ \func{socket}, \func{bind} e \func{listen}. Completata l'apertura passiva il
+ server chiama la funzione \func{accept} e il processo si blocca in attesa di
+ connessioni.
\item Il client richiede l'inizio della connessione usando la funzione
- \texttt{connect}, attraverso un procedimento che viene chiamato
+ \func{connect}, attraverso un procedimento che viene chiamato
\textsl{apertura attiva}, dall'inglese \textit{active open}. La chiamata di
- \texttt{connect} blocca il processo e causa l'invio da parte del client di
- un segmento \texttt{SYN}\footnote{Si ricordi che il segmento è l'unità
- elementare di dati trasmessa dal protocollo TCP al livello superiore;
- tutti i segmenti hanno un header che contiene le informazioni che servono
- allo \textit{stack TCP} (così viene di solito chiamata la parte del kernel
- che implementa il protocollo) per realizzare la comunicazione, fra questi
- dati ci sono una serie di flag usati per gestire la connessione, come
- \texttt{SYN}, \texttt{ACK}, \texttt{URG}, \texttt{FIN}, alcuni di essi,
- come \texttt{SYN} (che sta per \textit{syncronize}) corrispondono a
- funzioni particolari del protocollo e danno il nome al segmento, (per
- maggiori dettagli vedere \capref{cha:tcp_protocol})}, in sostanza viene
- inviato al server un pacchetto IP che contiene solo gli header IP e TCP (con
- il numero di sequenza iniziale e il flag \texttt{SYN}) e le opzioni di TCP.
+ \func{connect} blocca il processo e causa l'invio da parte del client di un
+ segmento SYN\footnote{Si ricordi che il segmento è l'unità elementare di
+ dati trasmessa dal protocollo TCP al livello superiore; tutti i segmenti
+ hanno un header che contiene le informazioni che servono allo
+ \textit{stack TCP} (così viene di solito chiamata la parte del kernel che
+ implementa il protocollo) per realizzare la comunicazione, fra questi dati
+ ci sono una serie di flag usati per gestire la connessione, come SYN, ACK,
+ URG, FIN, alcuni di essi, come SYN (che sta per \textit{syncronize})
+ corrispondono a funzioni particolari del protocollo e danno il nome al
+ segmento, (per maggiori dettagli vedere \capref{cha:tcp_protocol})}, in
+ sostanza viene inviato al server un pacchetto IP che contiene solo gli
+ header IP e TCP (con il numero di sequenza iniziale e il flag SYN) e le
+ opzioni di TCP.
-\item il server deve dare ricevuto (l'\textit{acknowledge}) del \texttt{SYN}
- del client, inoltre anche il server deve inviare il suo \texttt{SYN} al
- client (e trasmettere il suo numero di sequenza iniziale) questo viene fatto
- ritrasmettendo un singolo segmento in cui entrambi i flag \texttt{SYN}
- \texttt{ACK} e sono settati.
+\item il server deve dare ricevuto (l'\textit{acknowledge}) del SYN del
+ client, inoltre anche il server deve inviare il suo SYN al client (e
+ trasmettere il suo numero di sequenza iniziale) questo viene fatto
+ ritrasmettendo un singolo segmento in cui entrambi i flag SYN ACK e sono
+ settati.
\item una volta che il client ha ricevuto l'acknowledge dal server la funzione
- \texttt{connect} ritorna, l'ultimo passo è dare dare il ricevuto del
- \texttt{SYN} del server inviando un \texttt{ACK}. Alla ricezione di
- quest'ultimo la funzione \texttt{accept} del server ritorna e la connessione
- è stabilita.
+ \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
\begin{figure}[htb]
\centering
- \includegraphics[width=10cm]{img/three_way_handshake.eps}
+ \includegraphics[width=10cm]{img/three_way_handshake}
\caption{Il \textit{three way handshake} del TCP}
\label{fig:TCPel_TWH}
\end{figure}
\textsl{numero di sequenza iniziale} generato in maniera casuale del kernel
all'inizio della connessione e trasmesso con il SYN; l'acknowledgement di
ciascun segmento viene effettuato dall'altro capo della connessione settando
-il flag \texttt{ACK} e restituendo nell'apposito campo dell'header un
+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
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 \texttt{TCP\_MAXSEG}.
+ attraverso l'opzione del socket \macro{TCP\_MAXSEG}.
\item \textit{window scale option}; come spiegato in \capref{cha:tcp_protocol}
il protocollo TCP implementa il controllo di flusso attraverso una
seguente:
\begin{enumerate}
-\item Un processo ad uno dei due capi chiama la funzione \texttt{close}, dando
+\item Un processo ad uno dei due capi chiama la funzione \func{close}, dando
l'avvio a quella che viene chiamata \textsl{chiusura attiva} (o
\textit{active close}). Questo comporta l'emissione di un segmento FIN, che
significa che si è finito con l'invio dei dati sulla connessione.
riceveranno altri dati sulla connessione.
\item Dopo un certo tempo anche il secondo processo chiamerà la funzione
- \texttt{close} sul proprio socket, causando l'emissione di un altro segmento
+ \func{close} sul proprio socket, causando l'emissione di un altro segmento
FIN.
\item L'altro capo della connessione riceverà il FIN conclusivo e risponderà
\begin{figure}[htb]
\centering
- \includegraphics[width=10cm]{img/tcp_close.eps}
+ \includegraphics[width=10cm]{img/tcp_close}
\caption{La chiusura di una connessione TCP}
\label{fig:TCPel_close}
\end{figure}
socket dal lato che esegue la chiusura attiva; esistono tuttavia situazioni in
cui si vuole poter sfuttare questa possibilità, usando una procedura che è
chiamata \textit{half-close}; torneremo su questo aspetto e su come
-utilizzarlo più avanti, quando parleremo della funzione \texttt{shutdown}.
+utilizzarlo più avanti, quando parleremo della funzione \func{shutdown}.
La emissione del FIN avviene quando il socket viene chiuso, questo però non
-avviene solo per la chiamata della funzione \texttt{close} (come in
+avviene solo per la chiamata della funzione \func{close} (come in
\figref{fig:net_serv_code}), ma anche alla terminazione di un processo (come
in \figref{fig:net_cli_code}). Questo vuol dire ad esempio che se un processo
viene terminato da un segnale tutte le connessioni aperte verranno chiuse.
\begin{figure}[htb]
\centering
- \includegraphics[width=9cm]{img/tcp_connection.eps}
+ \includegraphics[width=9cm]{img/tcp_connection}
\caption{Schema dello scambio di pacchetti per un esempio di connessione}
\label{fig:TPCel_conn_example}
\end{figure}
\begin{figure}[!htb]
\centering
- \includegraphics[width=10cm]{img/tcpip_overview.eps}
+ \includegraphics[width=10cm]{img/port_alloc}
\caption{Allocazione dei numeri di porta}
\label{fig:TCPel_port_alloc}
\end{figure}
posto in ascolto per connessioni provenienti da uno qualunque degli indirizzi
associati alle interfacce locali; la notazione 0.0.0.0 usata da netstat è
equivalente all'asterisco utilizzato per il numero di porta ed indica il
-valore generico, e corrisponde al valore \texttt{INADDR\_ANY} definito in
-\texttt{arpa/inet.h}.
+valore generico, e corrisponde al valore \macro{INADDR\_ANY} definito in
+\file{arpa/inet.h}.
Inoltre la porta e l'indirizzo di ogni eventuale connessione esterna non sono
specificati; in questo caso la \textit{socket pair} associata al socket può
\texttt{daytime} che illustreremo in \secref{sec:TCPel_cunc_serv}.
-\subsection{La funzione \texttt{bind}}
+\subsection{La funzione \func{bind}}
\label{sec:TCPel_func_bind}
La funzione \func{bind} assegna un indirizzo locale ad un socket. È usata
Per questo nell'header \file{netinet/in.h} è definita una variabile
\type{in6addr\_any} (dichiarata come \type{extern}, ed inizializzata dal
sistema al valore \macro{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
-assegnazione del tipo: \footnotesize
+assegnazione del tipo:
+\footnotesize
\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
serv_add.sin6_addr = in6addr_any; /* connect from anywhere */
\end{lstlisting}
La funzione \func{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)}
di errore la variabile \var{errno} viene settata secondo i seguenti
codici di errore:
\begin{errlist}
- \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 \macro{EISCONN} il socket è già connesso.
+ \item \macro{ECONNREFUSED} non c'è nessuno in ascolto sull'indirizzo remoto.
+ \item \macro{ETIMEDOUT} si è avuto timeout durante il tentativo di
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 \macro{ENETUNREACH} la rete non è raggiungibile.
+ \item \macro{EADDRINUSE} l'indirizzo locale è in uso.
+ \item \macro{EINPROGRESS} il socket è non bloccante e la connessione non
può essere conclusa immediatamente.
- \item \texttt{EALREADY} il socket è non bloccante e un tentativo precedente
+ \item \macro{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 \macro{EAGAIN} non ci sono più porte locali libere.
+ \item \macro{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
+ \item \macro{EACCESS, EPERM} si è tentato di eseguire una connessione ad un
indirizzo broadcast senza che il socket fosse stato abilitato per il
broadcast.
\end{errlist}
nell'esempio \secref{sec:net_cli_sample} usando le funzioni illustrate in
\secref{sec:sock_addr_func}.
-Nel caso di socket TCP la funzione \texttt{connect} avvia il \textit{three way
+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
un server dopo le chiamate a \func{socket} e \func{bind} e prima della
chiamata ad \func{accept}. Il prototipo della funzione come definito dalla
man page è:
-
\begin{prototype}{sys/socket.h}{int listen(int sockfd, int backlog)}
La funzione pone il socket specificato da \var{sockfd} in modalità
passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
sono tutti nello stato \texttt{SYN\_RECV}.
\item Una 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 \texttt{accept} non è ritornata.
+ handshake è stato completato ma ancora \func{accept} non è ritornata.
Questi socket sono tutti nello stato \texttt{ESTABLISHED}.
\end{enumerate}
delle connessioni incomplete fino al ricevimento dell'ACK dal client o fino ad
un timeout. Nel caso di completamento del three way handshake l'entrata viene
sostata nella coda delle connessioni complete. Quando il processo chiama la
-funzione \texttt{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
+funzione \func{accept} (vedi \secref{sec:TCPel_func_accept}) la prima
entrata nella coda delle connessioni complete è passata al programma, o, se la
coda è vuota, il processo viene posto in attesa e risvegliato all'arrivo della
prima connessione completa.
-Storicamente il valore del parametro \texttt{backlog} era corrispondente al
+Storicamente il valore del parametro \var{backlog} era corrispondente al
massimo valore della somma del numero di entrate possibili per ciascuna di
dette code. Stevens riporta che BSD ha sempre applicato un fattore di 1.5 al
valore, e provvede una tabella con i risultati ottenuti con vari kernel,
compreso Linux 2.0, che mostrano le differenze fra diverse implementazioni.
In Linux il significato di questo valore è cambiato a partire dal kernel
-2.2 per prevenire l'attacco chiamato \texttt{syn flood}. Questo si basa
+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 \texttt{backlog} è stato cambiato a
+Per ovviare a questo il significato del \var{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 \texttt{sysctl} o scrivendola direttamente in
-\texttt{/proc/sys/net/ipv4/tcp\_max\_syn\_backlog}. Quando si attiva la
+la \func{sysctl} 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 \texttt{/proc/sys/net/ipv4/tcp\_syncookies}) questo valore
+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 \texttt{backlog} viene troncato ad un massimo di \texttt{SOMAXCONN}
+valore di \var{backlog} viene troncato ad un massimo di \macro{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
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ù
+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.
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
+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 \texttt{accept}}
+\subsection{La funzione \func{accept}}
\label{sec:TCPel_func_accept}
-La funzione \texttt{accept} è chiamata da un server TCP per gestire la
+La funzione \func{accept} è chiamata da un server TCP per gestire la
connessione una volta che sia stato completato il 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 listen(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
- La funzione estrae la prima connessione relativa al socket \texttt{sockfd}
+{int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)}
+ La funzione estrae la prima connessione relativa al socket \var{sockfd}
in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
- con le stesse caratteristiche di \texttt{sockfd} (restituito dalla funzione
+ con le stesse caratteristiche di \var{sockfd} (restituito dalla funzione
stessa). Il socket originale non viene toccato. Nella struttura
- \texttt{addr} e nella variabile \texttt{addrlen} vengono restituiti
+ \var{addr} e nella variabile \var{addrlen} vengono restituiti
indirizzo e relativa lunghezza del client che si è connesso.
La funzione restituisce un numero di socket descriptor positivo in caso di
- successo e -1 in caso di errore, nel qual caso la variabile \texttt{errno}
+ successo e -1 in caso di errore, nel qual caso la variabile \var{errno}
viene settata ai seguenti valori:
\begin{errlist}
- \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
+ \item \macro{EBADF} l'argomento \var{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 \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
+ \item \macro{EOPNOTSUPP} il socket è di un tipo che non supporta questa
operazione.
- \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} l'argomento \texttt{addr} .
- \item \texttt{EPERM} Firewall rules forbid connection.
+ \item \macro{EAGAIN} o \macro{EWOULDBLOCK} il socket è stato settato come
+ non bloccante, e non ci sono connessioni in attesa di essere accettate.
+ \item \macro{EFAULT} l'argomento \var{addr} .
+ \item \macro{EPERM} Firewall rules forbid connection.
- \item \texttt{ENOBUFS, ENOMEM} Not enough free memory. This often means
+ \item \macro{ENOBUFS, ENOMEM} Not enough free memory. This often means
that the memory allocation is limited by the socket buffer limits, not by
the system memory.
Inoltre possono essere restituiti gli errori di rete relativi al nuovo
- socket come: \texttt{EMFILE}, \texttt{EINVAL}, \texttt{ENOSR},
- \texttt{ENOBUFS}, \texttt{EPERM}, \texttt{ECONNABORTED},
- \texttt{ESOCKTNOSUPPORT}, \texttt{EPROTONOSUPPORT}, \texttt{ETIMEDOUT},
- \texttt{ERESTARTSYS}.
+ socket come: \macro{EMFILE}, \macro{EINVAL}, \macro{ENOSR},
+ \macro{ENOBUFS}, \macro{EPERM}, \macro{ECONNABORTED},
+ \macro{ESOCKTNOSUPPORT}, \macro{EPROTONOSUPPORT}, \macro{ETIMEDOUT},
+ \macro{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
+(cioè di tipo \macro{SOCK\_STREAM}, \macro{SOCK\_SEQPACKET} o
+\macro{SOCK\_RDM}). Per alcuni protocolli che richiedono una conferma
esplicita della connessione, (attualmente in Linux solo DECnet ha questo
comportamento), la funzione opera solo l'estrazione dalla coda delle
connessioni, la conferma della connessione viene fatta implicitamente dalla
-prima chiamata ad una \texttt{read} o una \texttt{write} mentre il rifiuto
-della connessione viene fatto con la funzione \texttt{close}.
+prima chiamata ad una \func{read} o una \func{write} mentre il rifiuto
+della connessione viene fatto 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
-\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
+\func{accept} passa gli errori di rete pendenti sul nuovo socket come codici
+di errore per \func{accept}. Inoltre la funzione non fa ereditare ai nuovi
+socket flag come \macro{O\_NONBLOCK}, che devono essere rispecificati volta
volta, questo è un comportamento diverso rispetto a quanto accade con BSD e
deve essere tenuto in conto per scrivere programmi portabili.
-I due argomenti \texttt{cliaddr} e \texttt{addrlen} (si noti che quest'ultimo
+I due argomenti \var{cliaddr} e \var{addrlen} (si noti che quest'ultimo
è passato per indirizzo per avere indietro il valore) sono usati per ottenere
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 argomento in \texttt{cliaddr}, al ritorno della
-funzione \texttt{addrlen} conterrà il numero di bytes scritti dentro
-\texttt{cliaddr}. Se questa informazione non interessa basterà inizializzare a
-\texttt{NULL} detti puntatori.
+\var{addrlen} deve essere inizializzato alle dimensioni della struttura il
+cui indirizzo è passato come argomento in \var{cliaddr}, al ritorno della
+funzione \var{addrlen} conterrà il numero di bytes scritti dentro
+\var{cliaddr}. Se questa informazione non interessa basterà inizializzare a
+\macro{NULL} detti puntatori.
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
+socket \var{sockfd}. Quest'ultimo (detto \textit{listening socket}) è
+quello creato all'inizio e messo in ascolto con \func{listen}, e non viene
toccato dalla funzione.
Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
il processo\footnote{a meno che non si sia settato il socket per essere
- non-bloccante, nel qual caso ritorna con l'errore \texttt{EAGAIN},
+ non-bloccante, nel qual caso ritorna con l'errore \func{EAGAIN},
torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
fintanto che non ne arriva una.
-Il meccanismo di funzionamento di \texttt{accept} è essenziale per capire il
+Il meccanismo di funzionamento di \func{accept} è essenziale per capire il
funzionamento di un server: in generale infatti c'è sempre un solo socket in
ascolto, che resta per tutto il tempo nello stato \texttt{LISTEN}, mentre le
-connessioni vengono gestite dai nuovi socket ritornati da \texttt{accept} che
+connessioni vengono gestite dai nuovi socket ritornati da \func{accept} che
si trovano automaticamente nello stato \texttt{ESTABLISHED} e utilizzati fino
alla chiusura della connessione che avviene su di essi. Si può riconoscere
questo schema anche nell'esempio elementare in \figref{fig:net_serv_code} dove
-per ogni connessione il socket creato da \texttt{accept} viene chiuso dopo
+per ogni connessione il socket creato da \func{accept} viene chiuso dopo
l'invio dei dati.
-\subsection{La funzione \texttt{close}}
+\subsection{La funzione \func{close}}
\label{sec:TCPel_func_close}
-La funzione standard unix \texttt{close} (vedi \secref{sec:file_close}) che si
+La funzione standard unix \func{close} (vedi \secref{sec:file_close}) che si
usa sui file può essere usata con lo stesso effetto anche sui socket
descriptor.
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
+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.
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.
+può usare la funzione \func{shutdown} su cui torneremo in seguito.
+
\section{I server concorrenti su TCP}
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
+usare la funzione \func{fork} per far creare al server per ogni richiesta da
parte di un client un processo figlio che si incarichi della gestione della
comunicazione.
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.
+\file{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti.
\begin{figure}[!htb]
\footnotesize
\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
+\func{accept} stavolta è chiamata fornendo una struttura di indirizzi in cui
saranno ritornati numero IP e porta da cui il client effettua la connessione,
che stamperemo, se avremo abilitato il logging, sullo standard output
(\texttt{\small 39--43}).
-Quando \texttt{accept} ritorna il server chiama la funzione \texttt{fork}
+Quando \func{accept} ritorna il server chiama la funzione \func{fork}
(\texttt{\small 26--30}) per creare il processo figlio che effettuerà tutte le
operazioni relative a quella connessione (\texttt{\small 31--45}), mentre il
padre resterà in attesa di ulteriori connessioni.
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}
+immediatamente il socket \var{list\_fd}; mentre il padre continua ad operare
+solo sul socket in ascolto chiudendo \var{sock\_fd} dopo ciascuna
+\func{accept}. Per quanto abbiamo detto in \secref{sec:TCPel_func_close}
queste due chiusure non causano l'innesco della sequenza di chiusura perché il
numero di riferimenti non si è annullato.
-Infatti subito dopo la creazione del socket \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
+Infatti subito dopo la creazione del socket \var{list\_fd} ha una
+referenza, e lo stesso vale per \var{sock\_fd} dopo il ritorno di
+\func{accept}, ma dopo la fork i descrittori vengono duplicati nel padre e
nel figlio per cui entrambi i socket si trovano con due referenze. Questo fa
-si che quando il padre chiude \texttt{sock\_fd} esso resta con una referenza
+si che quando il padre chiude \var{sock\_fd} esso resta con una referenza
da parte del figlio, e sarà definitivamente chiuso solo quando quest'ultimo,
-dopo aver completato le sue operazioni, chiamerà la funzione \texttt{close}.
+dopo aver completato le sue operazioni, chiamerà la funzione \func{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
+\func{close} in quanto nella \func{exit} tutti i file ed i socket vengono
chiusi, ma si è preferito effettuare la chiusura esplicitamente per avere una
maggiore chiarezza del codice ed evitare possibili errori.
Si noti come sia essenziale che il padre chiuda ogni volta il socket connesso
-dopo la \texttt{accept}; se così non fosse nessuno di questi socket sarebbe
+dopo la \func{accept}; se così non fosse nessuno di questi socket sarebbe
effettivamente chiuso dato che alla chiusura da parte del figlio resterebbe
ancora un riferimento. Si avrebbero così due effetti, il padre potrebbe
esaurire i descrittori disponibili (che sono un numero limitato per ogni
chiusa.
-\subsection{Le funzioni \texttt{getsockname} e \texttt{getpeername}}
+\subsection{Le funzioni \func{getsockname} e \func{getpeername}}
\label{sec:TCPel_get_names}
Queste due funzioni vengono usate per ottenere la socket pair associata ad un
{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:
+ codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
+ \item \macro{EBADF} l'argomento \var{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
+ \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
+ \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
eseguire l'operazione.
- \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
+ \item \macro{EFAULT} l'argomento \var{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
+La funzione \func{getsockname} si usa tutte le volte che si vuole avere
l'indirizzo locale di un socket; ad esempio può essere usata da un client (che
-usualmente non chiama \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
+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 \texttt{bind} su un indirizzo generico, se
+Inoltre quando un server esegue una \func{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
+\func{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:
+ codici di errore restituiti in \var{errno} sono i seguenti:
\begin{errlist}
- \item \texttt{EBADF} l'argomento \texttt{sockfd} non è un file descriptor
+ \item \macro{EBADF} l'argomento \var{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
+ \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
+ \item \macro{ENOTCONN} il socket non è connesso.
+ \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
eseguire l'operazione.
- \item \texttt{EFAULT} l'argomento \texttt{name} punta al di fuori dello
+ \item \macro{EFAULT} l'argomento \var{name} punta al di fuori dello
spazio di indirizzi del processo.
\end{errlist}
\end{prototype}
-La funzione \texttt{getpeername} si usa tutte le volte che si vuole avere
+La funzione \func{getpeername} si usa tutte le volte che si vuole avere
l'indirizzo remoto di un socket.
Ci si può chiedere a cosa serva questa funzione dato che dal lato client
-l'indirizzo remoto è sempre noto quando si esegue la \texttt{connect} mentre
+l'indirizzo remoto è sempre noto quando si esegue la \func{connect} mentre
dal lato server si possono usare, come si è fatto nell'esempio precedente, i
-valori di ritorno di \texttt{accept}.
+valori di ritorno di \func{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}
+opportuno programma per ciascuna connessione usando \func{exec} (questa ad
+esempio è la modailità con cui opera il \textsl{super-server} \cmd{inetd}
che gestisce tutta una serie di servizi lanciando per ogni connessione
l'opportuno server).
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
+ritornata da \func{accept}), all'esecuzione di \func{exec} viene caricata
in memoria l'immagine del programma eseguito che a questo punto perde ogni
riferimento. Il socket descriptor però resta aperto. Allora se una opportuna
convenzione è seguita per rendere noto al programma eseguito qual'è il socket
-connesso (\texttt{inetd} ad esempio fa sempre in modo che i file descriptor 0,
+connesso (\cmd{inetd} ad esempio fa sempre in modo che i file descriptor 0,
1 e 2 corrispondano al socket connesso) quest'ultimo potrà usare la funzione
-\texttt{getpeername} per determinare l'indirizzo remoto del client.
+\func{getpeername} per determinare l'indirizzo remoto del client.
-Infine è da chiarire (si legga la man page) che come per \texttt{accept} il
+Infine è da chiarire (si legga la man page) che come per \func{accept} il
terzo parametro che è specificato dallo standard POSIX 1003.1g come di tipo
-\texttt{socklen\_t *} in realtà deve sempre corrispondere ad un \texttt{int *}
+\type{socklen\_t *} in realtà deve sempre corrispondere ad un \type{int *}
come prima dello standard perché tutte le implementazioni dei socket BSD fanno
questa assunzione.
+
projects / gapil.git / blobdiff