X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=elemtcp.tex;h=9d2df4a87e1fa3b3897929a7afc6a20ee8ef4dfd;hp=c538c3f07cb01642fe33ff6c64faa8e76122de5d;hb=0ab3f419ed7721862f3a3bc012d681fbefdf0cfa;hpb=1bef617f629180c1e3b2e622f262e59acb87ba38 diff --git a/elemtcp.tex b/elemtcp.tex index c538c3f..9d2df4a 100644 --- a/elemtcp.tex +++ b/elemtcp.tex @@ -36,38 +36,37 @@ creazione di una connessione \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 @@ -86,7 +85,7 @@ la connessione. \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} @@ -102,7 +101,7 @@ 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 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 @@ -122,7 +121,7 @@ regolare la connessione. Normalmente vengono usate le seguenti opzioni: 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 @@ -167,7 +166,7 @@ riferimento al codice degli esempi \figref{fig:net_cli_code} e 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. @@ -181,7 +180,7 @@ seguente: 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à @@ -198,7 +197,7 @@ stabilisce la connessione. \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} @@ -213,10 +212,10 @@ Nella sequenza indicata i dati verrebbero persi, dato che si 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. @@ -270,7 +269,7 @@ ad assumere per i due lati, server e client. \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} @@ -477,7 +476,7 @@ disposizione del kernel per gestire le relative tabelle. \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} @@ -531,8 +530,8 @@ 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 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ò @@ -627,7 +626,7 @@ 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}} +\subsection{La funzione \func{bind}} \label{sec:TCPel_func_bind} La funzione \func{bind} assegna un indirizzo locale ad un socket. È usata @@ -706,7 +705,8 @@ assegnazione. 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} @@ -718,7 +718,6 @@ assegnazione del tipo: \footnotesize 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)} @@ -731,20 +730,20 @@ connessione con un server TCP, il prototipo della funzione 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} @@ -757,7 +756,7 @@ numero di porta del server a cui ci si vuole connettere, come mostrato 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 @@ -824,7 +823,6 @@ sostanza l'effetto della funzione 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 @@ -859,7 +857,7 @@ infatti vengono mantenute due code: 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} @@ -869,34 +867,34 @@ incomplete, e poi risponde con il SYN$+$ACK. La entrata rester 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 @@ -911,7 +909,7 @@ ricompilazione del server) ma usare piuttosto una variabile di ambiente (vedi 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. @@ -922,120 +920,118 @@ condizione in cui le code sono piene 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. @@ -1051,7 +1047,8 @@ 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. +può usare la funzione \func{shutdown} su cui torneremo in seguito. + \section{I server concorrenti su TCP} @@ -1065,7 +1062,7 @@ 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 +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. @@ -1081,7 +1078,7 @@ 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. +\file{ElemDaytimeTCPCuncServ.c} è allegato nella directory dei sorgenti. \begin{figure}[!htb] \footnotesize @@ -1145,38 +1142,38 @@ int main(int argc, char *argv[]) \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 @@ -1184,7 +1181,7 @@ processo) e soprattutto nessuna delle connessioni con i client verrebbe 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 @@ -1195,78 +1192,78 @@ remoto. {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. +