1 \chapter{Introduzione ai socket}
2 \label{cha:socket_intro}
4 In questo capitolo inizieremo a spiegare le caratteristiche principali della
5 principale interfaccia per la programmazione di rete, quella dei
6 \textit{socket}, che pur essendo nata in unix è usata ormai da tutti i sistemi
9 Dopo una breve panoramica sulle caratteristiche di questa interfaccia vedremo
10 come creare un socket e come collegarlo allo specifico protocollo di rete che
11 utilizzerà per la comunicazione. Per evitare una introduzione puramente teorica
12 concluderemo il capitolo con un primo esempio di applicazione.
14 \section{Una panoramica}
15 \label{sec:sock_overview}
17 Iniziamo con una descrizione essenziale di cosa sono i \textit{socket} e di
18 quali sono i concetti fondamentali da tenere presente quando si ha a che fare
21 \subsection{I \textit{socket}}
22 \label{sec:sock_socket_def}
24 Il \textit{socket}\footnote{una traduzione letterale potrebbe essere
25 \textsl{manicotto}, ma essendo universalmente noti come socket utilizzeremo
26 sempre la parola inglese} è uno dei principali meccanismi di comunicazione
27 fra programmi utilizzato in ambito unix. Il socket costituisce in sostanza un
28 canale di comunicazione fra due processi su cui si possono leggere e scrivere
29 dati analogo a quello di una pipe ma a differenza di questa e degli altri
30 meccanismi esaminati nel capitolo \capref{cha:IPC} i socket non sono limitati
31 alla comunicazione fra processi che girano sulla stessa macchina ma possono
32 effettuare la comunicazione anche attraverso la rete.
34 Quella dei socket costituisce infatti la principale API (\textit{Application
35 Program Interface}) usata nella programmazione di rete. La loro origine
36 risale al 1983, quando furono introdotti nel BSD 4.2; l'interfaccia è rimasta
37 sostanzialmente la stessa con piccole modifiche negli anni successivi. Benché
38 siano state sviluppate interfacce alternative, originate dai sistemi SYSV,
39 come la XTI (\textit{X/Open Transport Interface}) nessuna ha mai raggiunto la
40 diffusione e la popolarità di quella dei socket (né tantomeno usabilità e
43 La flessibilità e la genericità dell'interfaccia inoltre ha consentito di
44 utilizzare i socket con i più disparati meccanismi di comunicazione, e non
45 solo con la suite dei protocolli TCP/IP, che sarà comunque quella di cui
46 tratteremo in maniera più estesa.
49 \subsection{Concetti base}
52 Per capire il funzionamento dei socket occorre avere presente il funzionamento
53 dei protocolli di rete (vedi \capref{cha:network}), ma l'interfaccia è del
54 tutto generale e benché le problematiche (e quindi le modalità di risolvere i
55 problemi) siano diverse a seconda del tipo di protocollo di comunicazione
56 usato, le funzioni da usare restano le stesse.
58 Per questo motivo una semplice descrizione dell'interfaccia è assolutamente
59 inutile, in quanto il comportamento di quest'ultima e le problematiche da
60 affrontare cambiano radicalmente a seconda dello ``stile'' di comunicazione
61 usato. La scelta di questo stile va infatti ad incidere sulla semantica che
62 verrà utilizzata a livello utente per gestire la comunicazione (su come
63 inviare e ricevere i dati) e sul comportamento effettivo delle funzioni
66 La scelta di uno stile dipende sia dai meccanismi disponibili, sia dal tipo di
67 comunicazione che si vuole effettuare. Ad esempio alcuni stili di
68 comunicazione considerano i dati come una sequenza continua di bytes, altri
69 invece li raggruppano in blocchi (i pacchetti).
71 Un'altro esempio di stile concerne la possibilità che la comunicazione possa o
72 meno perdere dati, possa o meno non rispettare l'ordine in cui essi non sono
73 inviati, o inviare dei pacchetti più volte (come nel caso di TCP e UDP).
75 Un terzo esempio di stile di comunicazione concerne le modalità in cui essa
76 avviene, in certi casi essa può essere condotta con una connessione diretta
77 con un solo partner come per una telefonata; altri casi possono prevedere una
78 comunicazione come per lettera, in cui si scrive l'indirizzo su ogni
79 pacchetto, altri ancora una comunicazione \textit{broadcast} come per la
80 radio, in cui i pacchetti vengono emessi su appositi ``canali'' dove chiunque
81 si collega possa riceverli.
83 É chiaro che ciascuno di questi stili comporta una modalità diversa di gestire
84 la comunicazione, ad esempio se è inaffidabile occorrerà essere in grado di
85 gestire la perdita o il rimescolamento dei dati.
88 \section{La creazione di un \textit{socket}}
89 \label{sec:sock_creation}
91 Come accennato l'interfaccia dei socket è estremamente flessibile e permette
92 di interagire con protocolli di comunicazione anche molto diversi fra di loro;
93 in questa sezione vedremo come è possibile creare un socket e come specificare
94 il tipo di comunicazione che esso deve utilizzare.
96 \subsection{La funzione \texttt{socket}}
97 \label{sec:sock_socket}
99 La creazione di un socket avviene attraverso l'uso della funzione
100 \texttt{socket} questa restituisce un \textit{socket descriptor} (un valore
101 intero non negativo) che come gli analoghi file descriptor di file e alle
102 pipe serve come riferimento al socket; in sostanza è l'indice nella tabella
103 dei file che contiene i puntatori alle opportune strutture usate dal kernel ed
104 allocate per ogni processo, (la stessa usata per i files e le pipes [NdA
107 La funzione prende tre parametri, il dominio del socket (che definisce la
108 famiglia di protocolli, vedi \secref{sec:sock_domain}), il tipo di socket (che
109 definisce lo stile di comunicazione vedi \secref{sec:sock_type}) e il
110 protocollo; in genere quest'ultimo è indicato implicitamente dal tipo di
111 socket, per cui viene messo a zero (con l'eccezione dei \textit{raw socket}).
113 \begin{prototype}{sys/socket.h}{int socket(int domain, int type, int protocol)}
115 La funzione restituisce un intero positivo se riesce, e -1 se fallisce, in
116 quest'ultimo caso la variabile \texttt{errno} è settata con i seguenti
120 \item \texttt{EPROTONOSUPPORT} Il tipo di socket o il protocollo scelto non
121 sono supportati nel dominio.
122 \item \texttt{ENFILE} Il kernel non ha memoria sufficiente a creare una
123 nuova struttura per il socket.
124 \item \texttt{EMFILE} Si è ecceduta la tabella dei file.
125 \item \texttt{EACCES} Non si hanno privilegi per creare un socket nel
126 dominio o con il protocollo specificato.
127 \item \texttt{EINVAL} Protocollo sconosciuto o dominio non disponibile.
128 \item \texttt{ENOBUFS} o \texttt{ENOMEM} Non c'è sufficiente memoria per
133 Si noti che la creazione del socket non comporta nulla riguardo
134 all'indicazione degli indirizzi remoti o locali attraverso i quali si vuole
135 effettuare la comunicazione.
137 \subsection{Il dominio, o \textit{protocol family}}
138 \label{sec:sock_domain}
140 Dati i tanti e diversi protocolli di comunicazione disponibili, esistono vari
141 tipi di socket, che vengono classificati raggruppandoli in quelli che si
142 chiamano \textsl{domini}. La scelta di un dominio equivale in sostanza alla
143 scelta di una famiglia di protocolli. Ciascun dominio ha un suo nome simbolico
144 che convenzionalmente inizia con \texttt{PF\_} da \textit{protocol family},
145 altro nome con cui si indicano i domini.
147 A ciascun tipo di dominio corrisponde un analogo nome simbolico che inizia per
148 \texttt{AF\_} da \textit{address family}, e che identifica il formato degli
149 indirizzi usati in quel dominio; le man pages di Linux si riferiscono a questi
150 anche come \textit{name space}, (nome che però il manuale della glibc riserva
151 ai domini) e che identifica il formato degli indirizzi usati in quel dominio.
153 L'idea alla base della distinzione era che una famiglia di protocolli potesse
154 supportare vari tipi di indirizzi, per cui il prefisso \texttt{PF\_} si
155 sarebbe dovuto usare nella creazione dei socket e il prefisso \texttt{AF\_} in
156 quello delle strutture degli indirizzi; questo è quanto specificato anche
157 dallo standard POSIX.1g, ma non esistono a tuttora famiglie di protocolli che
158 supportino diverse strutture di indirizzi, per cui nella pratica questi due
159 nomi sono equivalenti e corrispondono agli stessi valori.
161 I domini (e i relativi nomi simbolici), così come i nomi delle famiglie di
162 indirizzi sono definiti dall'header \textit{socket.h}. In Linux le famiglie di
163 protocolli disponibili sono riportate in \ntab.
168 \begin{tabular}[c]{lll}
170 \textsl{Nome} & \textsl{Utilizzo} &\textsl{Man page} \\
173 PF\_UNIX,PF\_LOCAL & Local communication & unix(7) \\
174 PF\_INET & IPv4 Internet protocols & ip(7) \\
175 PF\_INET6 & IPv6 Internet protocols & \\
176 PF\_IPX & IPX - Novell protocols & \\
177 PF\_NETLINK & Kernel user interface device & netlink(7) \\
178 PF\_X25 & ITU-T X.25 / ISO-8208 protocol & x25(7) \\
179 PF\_AX25 & Amateur radio AX.25 protocol & \\
180 PF\_ATMPVC & Access to raw ATM PVCs & \\
181 PF\_APPLETALK & Appletalk & ddp(7) \\
182 PF\_PACKET & Low level packet interface & packet(7) \\
185 \caption{Famiglie di protocolli definiti in Linux}
186 \label{tab:net_pf_names}
189 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
190 esempio in generale tutti i socket di tipo \macro{SOCK\_RAW} possono essere
191 creati solo da processi che hanno i privilegi di root (cioè effective uid
192 uguale a zero) o la capability \macro{CAP\_NET\_RAW}.
195 \subsection{Il tipo, o stile}
196 \label{sec:sock_type}
198 La scelta di un dominio non comporta però la scelta dello stile di
199 comunicazione, questo infatti viene a dipendere dal protocollo che si andrà ad
200 utilizzare fra quelli disponibili nella famiglia scelta. Le API permettono di
201 scegliere lo stile di comunicazione indicando il tipo di socket; Linux e le
202 glibc mettono a disposizione i seguenti tipi di socket (che il manuale della
203 glibc chiama \textit{styles}) definiti come \type{int} in \file{socket.h}:
206 \item \macro{SOCK\_STREAM} Provvede un canale di trasmissione dati
207 bidirezionale, sequenziale e affidabile. Opera su una connessione con un
208 altro socket. I dati vengono ricevuti e trasmessi come un flusso continuo di
209 byte (da cui il nome \textit{stream}).
210 \item \macro{SOCK\_DGRAM} Viene usato per mandare pacchetti di lunghezza
211 massima fissata (\textit{datagram}) indirizzati singolarmente, senza
212 connessione e in maniera non affidabile. È l'opposto del precedente.
213 \item \macro{SOCK\_SEQPACKET} Provvede un canale di trasmissione di dati
214 bidirezionale, sequenziale e affidabile. Opera su una connessione con un
215 altro socket. I dati possono solo essere trasmessi e letti per pacchetti (di
216 dimensione massima fissata).
217 \item \macro{SOCK\_RAW} Provvede l'accesso a basso livello ai protocolli di
218 rete e alle varie interfacce. I normali programmi di comunicazione non
220 \item \macro{SOCK\_RDM} Provvede un canale di trasmissione di pacchetti
221 affidabile ma in cui non è garantito l'ordine di arrivo dei pacchetti.
222 \item \macro{SOCK\_PACKET} Obsoleto, non deve essere usato.
225 Si tenga presente che non tutte le combinazioni di famiglia di protocolli e
226 tipo di socket sono valide, in quanto non è detto che nella famiglia esista un
227 protocollo per tutti gli stili di comunicazione indicati qui sopra. Una
228 tabella che mostra le combinazioni valide è la seguente:
233 \begin{tabular}{l|c|c|c|c|c|}
234 \multicolumn{1}{c}{} &\multicolumn{1}{c}{\macro{SOCK\_STREAM}}&
235 \multicolumn{1}{c}{\macro{SOCK\_DGRAM}} &
236 \multicolumn{1}{c}{\macro{SOCK\_RAW}} &
237 \multicolumn{1}{c}{\macro{SOCK\_PACKET}}&
238 \multicolumn{1}{c}{\macro{SOCK\_SEQPACKET}} \\
240 \macro{PF\_UNIX} & si & si & & & \\
242 \macro{PF\_INET} & TCP & UDP & IPv4 & & \\
244 \macro{PF\_INET6} & TCP & UDP & IPv6 & & \\
246 \macro{PF\_IPX} & & & & & \\
248 \macro{PF\_NETLINK} & & si & si & & \\
250 \macro{PF\_X25} & & & & & si \\
252 \macro{PF\_AX25} & & & & & \\
254 \macro{PF\_ATMPVC} & & & & & \\
256 \macro{PF\_APPLETALK} & & si & si & & \\
258 \macro{PF\_PACKET} & & si & si & & \\
261 \caption{Combinazioni valide di dominio e tipo di protocollo per la
262 funzione \func{socket}.}
263 \label{tab:sock_sock_valid_combinations}
266 Dove per ogni combinazione valida si è indicato il tipo di protocollo, o la
267 parola \textsl{si} qualora non il protocollo non abbia un nome definito,
268 mentre si sono lasciate vuote le caselle per le combinazioni non supportate.
272 \section{Le strutture degli indirizzi dei socket}
273 \label{sec:sock_sockaddr}
275 Come si è visto nella creazione di un socket non si specifica nulla oltre al
276 tipo di famiglia di protocolli che si vuole utilizzare, in particolare nessun
277 indirizzo che identifichi i due capi della comunicazione. La funzione infatti
278 si limita ad allocare nel kernel quanto necessario per poter poi realizzare la
281 Gli indirizzi vengono specificati attraverso apposite strutture che vengono
282 utilizzate dalle altre funzioni della API dei socket quando la comunicazione
283 viene effettivamente realizzata.
285 Ogni famiglia di protocolli ha ovviamente una sua forma di indirizzamento e in
286 corrispondenza a questa una sua peculiare struttura degli indirizzi; i nomi di
287 tutte queste strutture iniziano per \texttt{sockaddr\_}, quelli propri di
288 ciascuna famiglia vengono identificati dal suffisso finale, aggiunto al nome
292 \subsection{La struttura generica}
293 \label{sec:sock_sa_gen}
295 Le strutture degli indirizzi vengono sempre passate alle varie funzioni
296 attraverso puntatori (cioè \textit{by reference}), ma le funzioni devono poter
297 maneggiare puntatori a strutture relative a tutti gli indirizzi possibili
298 nelle varie famiglie di protocolli; questo pone il problema di come passare
299 questi puntatori, il C ANSI risolve questo problema coi i puntatori generici
300 (i \type{void *}), ma l'interfaccia dei socket è antecendente alla
301 definizione dello standard ANSI, e per questo nel 1982 fu scelto di definire
302 una struttura generica \type{sockaddr} per gli indirizzi dei socket mostrata
307 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
309 sa_family_t sa_family; /* address family: AF_xxx */
310 char sa_data[14]; /* address (protocol-specific) */
313 \caption{La struttura generica degli indirizzi dei socket \type{sockaddr}}
314 \label{fig:sock_sa_gen_struct}
317 Tutte le funzioni dei socket che usano gli indirizzi sono definite usando nel
318 prototipo un puntatore a questa struttura; per questo motivo quando si
319 invocano dette funzioni passando l'indirizzo di un protocollo specifico
320 occorrerà eseguire un casting del relativo puntatore.
322 I tipi di dati che compongono la struttura sono stabiliti dallo standard
323 POSIX.1g, riassunti in \ntab\ con i rispettivi file di include in cui sono
324 definiti; la struttura è invece definita nell'include file
329 \begin{tabular}{|l|l|l|}
331 \multicolumn{1}{|c|}{Tipo}& \multicolumn{1}{|c|}{Descrizione}&
332 \multicolumn{1}{|c|}{Header} \\
335 \texttt{int8\_t} & intero a 8 bit con segno & \texttt{sys/types.h}\\
336 \texttt{uint8\_t} & intero a 8 bit senza segno & \texttt{sys/types.h}\\
337 \texttt{int16\_t} & intero a 16 bit con segno & \texttt{sys/types.h}\\
338 \texttt{uint16\_t} & intero a 16 bit senza segno& \texttt{sys/types.h}\\
339 \texttt{int32\_t} & intero a 32 bit con segno & \texttt{sys/types.h}\\
340 \texttt{uint32\_t} & intero a 32 bit senza segno& \texttt{sys/types.h}\\
342 \texttt{sa\_family\_t} & famiglia degli indirizzi& \texttt{sys/socket.h}\\
343 \texttt{socklen\_t} & lunghezza (\texttt{uint32\_t}) dell'indirizzo di
344 un socket& \texttt{sys/socket.h}\\
346 \texttt{in\_addr\_t} & indirizzo IPv4 (\texttt{uint32\_t}) &
347 \texttt{netinet/in.h}\\
348 \texttt{in\_port\_t} & porta TCP o UDP (\texttt{uint16\_t})&
349 \texttt{netinet/in.h}\\
352 \caption{Tipi di dati usati nelle strutture degli indirizzi, secondo quanto
353 stabilito dallo standard POSIX.1g}
354 \label{tab:sock_data_types}
357 In alcuni sistemi la struttura è leggermente diversa e prevede un primo membro
358 aggiuntivo \texttt{uint8\_t sin\_len} (come riportato da R. Stevens nei suoi
359 libri). Questo campo non verrebbe usato direttamente dal programmatore e non è
360 richiesto dallo standard POSIX.1g, in Linux pertanto non esiste. Il campo
361 \type{sa\_family\_t} era storicamente un \type{unsigned short}.
363 Dal punto di vista del programmatore l'unico uso di questa struttura è quello
364 di fare da riferimento per il casting, per il kernel le cose sono un po'
365 diverse, in quanto esso usa il puntatore per recuperare il campo
366 \texttt{sa\_family} con cui determinare il tipo di indirizzo; per questo
367 motivo, anche se l'uso di un puntatore \texttt{void *} sarebbe più immediato
368 per l'utente (che non dovrebbe più eseguire il casting), è stato mantenuto
369 l'uso di questa struttura.
372 \subsection{La struttura degli indirizzi IPv4}
373 \label{sec:sock_sa_ipv4}
375 I socket di tipo \macro{PF\_INET} vengono usati per la comunicazione
376 attraverso internet; la struttura per gli indirizzi per un socket internet
377 (IPv4) è definita come \type{sockaddr\_in} nell'header file
378 \texttt{netinet/in.h} e secondo le man page ha la forma mostrata in \nfig,
379 conforme allo standard POSIX.1g.
383 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
385 sa_family_t sin_family; /* address family: AF_INET */
386 u_int16_t sin_port; /* port in network byte order */
387 struct in_addr sin_addr; /* internet address */
389 /* Internet address. */
391 u_int32_t s_addr; /* address in network byte order */
394 \caption{La struttura degli indirizzi dei socket internet (IPv4)
395 \texttt{sockaddr\_in}.}
396 \label{fig:sock_sa_ipv4_struct}
399 L'indirizzo di un socket internet (secondo IPv4) comprende l'indirizzo
400 internet di un'interfaccia più un numero di porta. Il protocollo IP non
401 prevede numeri di porta, che sono utilizzati solo dai protocolli di livello
402 superiore come TCP e UDP. Questa struttura però viene usata anche per i socket
403 RAW che accedono direttamente al livello di IP, nel qual caso il numero della
404 porta viene settato al numero di protocollo.
406 Il membro \texttt{sin\_family} deve essere sempre settato; \texttt{sin\_port}
407 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
408 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
409 servizi standard. Soltanto processi con i privilegi di root (effective uid
410 uguale a zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE} possono
411 usare la funzione \func{bind} su queste porte.
413 Il membro \texttt{sin\_addr} contiene l'indirizzo internet dell'altro capo
414 della comunicazione, e viene acceduto sia come struttura (un resto di una
415 implementazione precedente in cui questa era una \texttt{union} usata per
416 accedere alle diverse classi di indirizzi) che come intero.
418 Infine è da sottolineare che sia gli indirizzi che i numeri di porta devono
419 essere specificati in quello che viene chiamato \textit{network order}, cioè
420 con i bit ordinati in formato \textit{big endian}, questo comporta la
421 necessità di usare apposite funzioni di conversione per mantenere la
422 portabilità del codice (vedi \secref{sec:sock_addr_func} per i dettagli del
423 problema e le relative soluzioni).
426 \subsection{La struttura degli indirizzi IPv6}
427 \label{sec:sock_sa_ipv6}
429 Essendo IPv6 una estensione di IPv4 i socket di tipo \texttt{PF\_INET6} sono
430 sostanzialmente identici ai precedenti; la parte in cui si trovano
431 praticamente tutte le differenze è quella della struttura degli indirizzi. La
432 struttura degli indirizzi è definita ancora in \texttt{netinet/in.h}.
436 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
437 struct sockaddr_in6 {
438 u_int16_t sin6_family; /* AF_INET6 */
439 u_int16_t sin6_port; /* port number */
440 u_int32_t sin6_flowinfo; /* IPv6 flow information */
441 struct in6_addr sin6_addr; /* IPv6 address */
442 u_int32_t sin6_scope_id; /* Scope id (new in 2.4) */
446 unsigned char s6_addr[16]; /* IPv6 address */
449 \caption{La struttura degli indirizzi dei socket IPv6
450 \texttt{sockaddr\_in6}.}
451 \label{fig:sock_sa_ipv6_struct}
454 Il campo \texttt{sin6\_family} deve essere sempre settato ad
455 \texttt{AF\_INET6}, il campo \texttt{sin6\_port} è analogo a quello di IPv4 e
456 segue le stesse regole; il campo \texttt{sin6\_flowinfo} è a sua volta diviso
457 in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
458 successivi 4 bit la priorità e gli ultimi 4 sono riservati; questi valori
459 fanno riferimento ad alcuni campi specifici dell'header dei pacchetti IPv6
460 (vedi \secref{sec:IP_ipv6head}) ed il loro uso è sperimentale.
462 Il campo \texttt{sin6\_addr} contiene l'indirizzo a 128 bit usato da IPv6,
463 infine il campo \texttt{sin6\_scope\_id} è un campo introdotto con il kernel
464 2.4 per gestire alcune operazioni riguardanti il multicasting.
466 Si noti che questa struttura è più grande di una \texttt{sockaddr} generica,
467 quindi occorre stare attenti a non avere fatto assunzioni riguardo alla
468 possibilità di contenere i dati nelle dimensioni di quest'ultima.
471 \subsection{La struttura degli indirizzi locali}
472 \label{sec:sock_sa_local}
474 I socket di tipo \texttt{PF\_UNIX} vengono usati per una comunicazione
475 efficiente fra processi che stanno sulla stessa macchina; essi rispetto ai
476 precedenti possono essere anche creati in maniera anonima attraverso la
477 funzione \texttt{socketpair}. Quando però si vuole fare riferimento esplicito
478 ad uno di questi socket si deve usare la seguente struttura di indirizzi
479 definita nel file di header \texttt{sys/un.h}.
483 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
484 #define UNIX_PATH_MAX 108
486 sa_family_t sun_family; /* AF_UNIX */
487 char sun_path[UNIX_PATH_MAX]; /* pathname */
490 \caption{La struttura degli indirizzi dei socket locali
491 \texttt{sockaddr\_un}.}
492 \label{fig:sock_sa_local_struct}
495 In questo caso il campo \texttt{sun\_family} deve essere \texttt{AF\_UNIX},
496 mentre il campo \texttt{sun\_path} deve specificare un indirizzo; questo ha
497 due forme un file (di tipo socket) nel filesystem o una stringa univoca
498 (tenuta in uno spazio di nomi astratto). Nel primo caso l'indirizzo viene
499 specificato come una stringa (terminata da uno zero) corrispondente al
500 pathname del file; nel secondo invece \texttt{sun\_path} inizia con uno zero
501 vengono usati i restanti bytes come stringa (senza terminazione).
504 % \subsection{Il passaggio delle strutture}
505 % \label{sec:sock_addr_pass}
507 % Come detto nelle funzioni della API dei socket le strutture degli indirizzi
508 % vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
509 % della struttura è passata come argomento, ma in questo caso la modalità del
510 % passaggio dipende dalla direzione del medesimo, dal processo al kernel o
513 % In particolare le tre funzioni \texttt{bind}, \texttt{connect} e
514 % \texttt{sendto} passano la struttura al kernel, in questo caso è passata
515 % \textsl{per valore} anche la dimensione della medesima
518 % Le funzioni \texttt{accept}, \texttt{recvfrom}, \texttt{getsockname} e
519 % \texttt{getpeername} invece ricevono i valori del kernel
523 \section{Le funzioni di conversione degli indirizzi}
524 \label{sec:sock_addr_func}
526 In questa sezione tratteremo delle varie funzioni usate per manipolare gli
527 indirizzi, limitandoci però agli indirizzi internet.
529 Come accennato gli indirizzi e i numeri di porta usati nella rete devono
530 essere forniti in formato opportuno (il \textit{network order}). Per capire
531 cosa significa tutto ciò occorre introdurre un concetto generale che tornerà
532 utile anche in seguito.
535 \subsection{La \textit{endianess}}
536 \label{sec:sock_endianess}
538 La rappresentazione di un numero binario in un computer può essere fatta in
539 due modi, chiamati rispettivamente \textit{big endian} e \textit{little
540 endian} a seconda di come i singoli bit vengono aggregati per formare le
541 variabili intere (in diretta corrispondenza a come sono poi in realtà cablati
542 sui bus interni del computer).
544 Per capire meglio il problema si consideri un intero a 16 bit scritto in una
545 locazione di memoria posta ad un certo indirizzo. I singoli bit possono essere
546 disposti un memoria in due modi, a partire dal più significativo o a partire
547 dal meno significativo. Così nel primo caso si troverà il byte che contiene i
548 bit più significativi all'indirizzo menzionato e il byte con i bit meno
549 significativi nell'indirizzo successivo; questo ordinamento è detto
550 \textit{little endian} dato che il dato finale è la parte ``piccola'' del
551 numero. Il caso opposto, in cui si parte dal bit meno significativo è detto
552 per lo stesso motivo \textit{big endian}.
554 La \textit{endianess} di un computer dipende essenzialmente dalla architettura
555 hardware usata; Intel e Digital usano il little endian, Motorola, IBM, Sun
556 (sostanzialmente tutti gli altri) usano il big endian. Il formato della rete è
557 anch'esso big endian, quello del bus PCI è little endian, quello del bus VME è
560 Esistono poi anche dei processori che possono scegliere il tipo di formato
561 all'avvio e alcuni, come il PowerPC o l'Intel i860, possono pure passare da un
562 tipo di ordinamento all'altro con una specifica istruzione; in ogni caso in
563 Linux l'ordinamento è definito dall'architettura e anche se questi cambiamenti
564 sono possibili anche dopo che il sistema è avviato, non vengono mai eseguiti.
566 \subsection{Le funzioni per il riordinamento}
567 \label{sec:sock_func_ord}
569 Il problema connesso all'endianess è che quando si passano dei dati da un tipo
570 di architettura all'altra i dati vengono interpretati in maniera diversa, e ad
571 esempio nel caso dell'intero a 16 bit ci si ritroverà con i due bytes in cui è
572 suddiviso scambiati di posto, e ne sarà quindi invertito l'ordine di lettura
573 per cui, per riavere il valore originale dovranno essere rovesciati.
575 Per questo motivo si usano le seguenti funzioni di conversione che servono a
576 tener conto automaticamente della possibile differenza fra l'ordinamento usato
577 sul computer e quello che viene usato nelle trasmissione sulla rete; queste
579 \begin{prototype}{netinet/in.h}
580 {unsigned long int htonl(unsigned long int hostlong)}
581 Converte l'intero a 32 bit \var{hostlong} dal formato della macchina a
584 \begin{prototype}{netinet/in.h}
585 {unsigned short int htons(unsigned short int hostshort)}
586 Converte l'intero a 16 bit \var{hostshort} dal formato della macchina a
589 \begin{prototype}{netinet/in.h}
590 {unsigned long int ntonl(unsigned long int netlong)}
591 Converte l'intero a 32 bit \var{netlong} dal formato della rete a quello
594 \begin{prototype}{netinet/in.h}
595 {unsigned sort int ntons(unsigned short int netshort)}
596 Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello
599 I nomi sono assegnati usando la lettera $n$ come mnemonico per indicare
600 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera $h$
601 come mnemonico per l'ordinamento usato sulla macchina locale (da \textit{host
602 order}), mentre le lettere $s$ e $l$ stanno ad indicare i tipi di dato
603 (\type{long} o \type{short}, riportati anche dai prototipi).
605 Usando queste funzioni si ha la conversione automatica (nel caso pure la
606 macchina sia in big endian queste funzioni sono definite come macro che non
607 fanno nulla); esse vanno sempre utilizzate per assicurare la portabilità del
608 codice su tutte le architetture.
611 \subsection{Le funzioni \func{inet\_aton}, \func{inet\_addr} e
613 \label{sec:sock_func_ipv4}
615 Un secondo insieme di funzioni di manipolazione serve per passare dal formato
616 binario usato nelle strutture degli indirizzi alla rappresentazione dei numeri
617 IP che si usa normalmente.
619 Le prime tre funzioni di manipolazione riguardano la conversione degli
620 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
621 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
622 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network
623 order}) e viceversa; in questo caso si usa la lettera $a$ come mnemonico per
624 indicare la stringa. Dette funzioni sono:
625 \begin{prototype}{arpa/inet.h}
626 {int inet\_aton(const char *src, struct in\_addr *dest)} Converte la stringa
627 puntata da \var{src} nell'indirizzo binario da memorizzare all'indirizzo
628 puntato da \var{dest}, restituendo 0 in caso di successo e 1 in caso di
629 fallimento (è espressa in questa forma in modo da poterla usare direttamente
630 con il puntatore usato per passare la struttura degli indirizzi). Se usata
631 con \var{dest} inizializzato a \macro{NULL} effettua la validazione
634 \begin{prototype}{arpa/inet.h}{in\_addr\_t inet\_addr(const char *strptr)}
635 Restituisce l'indirizzo a 32 bit in network order a partire dalla stringa
636 passata come parametro, in caso di errore restituisce il valore
637 \macro{INADDR\_NONE} che tipicamente sono trentadue bit a uno; questo
638 comporta che la stringa \texttt{255.255.255.255}, che pure è un indirizzo
639 valido, non può essere usata con questa funzione; per questo motivo essa è
640 generalmente deprecata in favore della precedente.
642 \begin{prototype}{arpa/inet.h}{char *inet\_ntoa(struct in\_addr addrptr)}
643 Converte il valore a 32 bit dell'indirizzo (espresso in network order)
644 restituendo il puntatore alla stringa che contiene l'espressione in formato
645 dotted decimal. Si deve tenere presente che la stringa risiede in memoria
646 statica, per cui questa funzione non è rientrante.
650 \subsection{Le funzioni \func{inet\_pton} e \func{inet\_ntop}}
651 \label{sec:sock_conv_func_gen}
653 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
654 motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e
655 \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in
656 questo caso le lettere $n$ e $p$ sono degli mnemonici per ricordare il tipo di
657 conversione effettuata e stanno per \textit{presentation} e \textit{numeric}.
659 % \begin{figure}[htb]
662 % \caption{Schema della rappresentazioni utilizzate dalle funzioni di
663 % conversione \texttt{inet\_pton} e \texttt{inet\_ntop} }
664 % \label{fig:sock_inet_conv_func}
668 Entrambe le funzioni accettano l'argomento \texttt{af} che indica il tipo di
669 indirizzo e può essere \texttt{AF\_INET} o \texttt{AF\_INET6}. Se la famiglia
670 indicata non è valida entrambe le funzioni settano la variabile \texttt{errno}
671 al valore \texttt{EAFNOSUPPORT}. I prototipi delle suddette funzioni sono i
673 \begin{prototype}{sys/socket.h}
674 {int inet\_pton(int af, const char *src, void *addr\_ptr)} Converte la
675 stringa puntata da \var{src} nell'indirizzo IP da memorizzare
676 all'indirizzo puntato da \var{addr\_ptr}, la funzione restituisce un
677 valore positivo in caso di successo, e zero se la stringa non rappresenta un
678 indirizzo valido, e negativo se \var{af} specifica una famiglia di indirizzi
682 \begin{prototype}{sys/socket.h}
683 {char *inet\_ntop(int af, const void *addr\_ptr, char *dest, size\_t len)}
684 Converte la struttura dell'indirizzo puntata da \var{addr\_ptr} in una
685 stringa che viene copiata nel buffer puntato dall'indirizzo \var{dest};
686 questo deve essere preallocato dall'utente e la lunghezza deve essere almeno
687 \macro{INET\_ADDRSTRLEN} in caso di indirizzi IPv4 e
688 \macro{INET6\_ADDRSTRLEN} per indirizzi IPv6; la lunghezza del buffer deve
689 comunque venire specificata attraverso il parametro \var{len}.
691 La funzione restituisce un puntatore non nullo a \var{dest} in caso di
692 successo e un puntatore nullo in caso di fallimento, in quest'ultimo caso
693 viene settata la variabile \texttt{errno} con il valore \macro{ENOSPC} in
694 caso le dimensioni dell'indirizzo eccedano la lunghezza specificata da
695 \var{len} o \macro{ENOAFSUPPORT} in caso \var{af} non sia una famiglia di
699 Gli indirizzi vengono cnovertiti da/alle rispettive strutture di indirizzo
700 (\var{struct in\_addr} per IPv4, e \var{struct in6\_addr} per IPv6), che
701 devono essere precedentemente allocate e passate attraverso il puntatore
702 \var{addr\_ptr}; il parametro \var{dest} di \func{inet\_ntop} non può essere
703 nullo e deve essere allocato precedentemente.
705 Il formato usato per gli indirizzi in formato di presentazione è la notazione
706 \textit{dotted decimal} per IPv4 e quella descritta in
707 \secref{sec:IP_ipv6_notation} per IPv6.
710 \section{Un esempio di applicazione}
711 \label{sec:sock_appplication}
713 Per evitare di rendere questa introduzione ai socket puramente teorica
714 iniziamo con il mostrare un esempio di un client TCP elementare. Prima di
715 passare agli esempi del client e del server, esamimeremo una caratteristica
716 delle funzioni di I/O sui socket che ci tornerà utile anche in seguito.
719 \subsection{Il comportamento delle funzioni di I/O}
720 \label{sec:sock_io_behav}
722 Una cosa di cui non sempre si è consapevoli quando si ha a che fare con i
723 socket è che le funzioni di input/output non sempre hanno lo stesso
724 comportamento che avrebbero con i normali files (in particolare questo accade
725 per i socket di tipo stream).
727 Infatti con i socket può accadere che funzioni come \func{read} o
728 \func{write} possano restituire in input o scrivere in output un numero di
729 bytes minore di quello richiesto. Questo è un comportamento normale e non un
730 errore, e succede perché si eccede in lettura o scrittura il limite di buffer
733 In questo caso tutto quello che il programma chiamante deve fare è di ripetere
734 la lettura (o scrittura) per la quantità di bytes rimanenti (lo stesso può
735 avvenire scrivendo più di 4096 bytes in una pipe, dato che quello è il limite
736 di solito adottato per il buffer di trasmissione del kernel).
744 ssize_t SockRead(int fd, void *buf, size_t count)
750 while (nleft > 0) { /* repeat until no left */
751 if ( (nread = read(fd, buf, nleft)) < 0) {
752 if (errno == EINTR) { /* if interrupted by system call */
753 continue; /* repeat the loop */
755 return(nread); /* otherwise exit */
757 } else if (nread == 0) { /* EOF */
758 break; /* break loop here */
760 nleft -= nread; /* set left to read */
761 buf +=nread; /* set pointer */
763 return (count - nleft);
766 \caption{Funzione \texttt{SockRead}, legge $n$ bytes da un socket }
767 \label{fig:sock_SockRead_code}
770 Per questo motivo seguendo l'esempio di W. R. Stevens si sono definite due
771 funzioni \texttt{SockRead} e \texttt{SockWrite} che eseguono la lettura da un
772 socket tenendo conto di questa caratteristica, ed in grado di ritornare dopo
773 avere letto o scritto esattamente il numero di bytes specificato; il sorgente
774 è riportato in \curfig\ e \nfig\ ed è disponibile fra i sorgenti allegati alla
775 guida nei files \texttt{SockRead.c} e \texttt{SockWrite.c}.
783 ssize_t SockWrite(int fd, const void *buf, size_t count)
789 while (nleft > 0) { /* repeat until no left */
790 if ( (nwritten = write(fd, buf, nleft)) < 0) {
791 if (errno == EINTR) { /* if interrupted by system call */
792 continue; /* repeat the loop */
794 return(nwritten); /* otherwise exit with error */
797 nleft -= nwritten; /* set left to write */
798 buf +=nwritten; /* set pointer */
803 \caption{Funzione \texttt{SockWrite}, scrive $n$ bytes su un socket }
804 \label{fig:sock_SockWrite_code}
807 Come si può notare le funzioni ripetono la lettura/scrittura in un loop fino
808 all'esaurimento del numero di bytes richiesti, in caso di errore viene
809 controllato se questo è \texttt{EINTR} (cioè un'interruzione della system call
810 dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
811 l'errore viene ritornato interrompendo il loop.
813 Nel caso della lettura se il numero di bytes letti è zero significa che è
814 arrivati alla fine del file e pertanto si ritorna senza aver concluso la
815 lettura di tutti i bytes richiesti.
819 \subsection{Un primo esempio di client}
820 \label{sec:net_cli_sample}
822 Lo scopo di questo esempio è fornire un primo approccio alla programmazione di
823 rete e vedere come si usano le funzioni descritte in precedenza, alcune delle
824 funzioni usate nell'esempio saranno trattate in dettaglio nel capitolo
825 successivo; qui ci limiteremo a introdurre la nomenclatura senza fornire
826 definizioni precise e dettagli di funzionamento che saranno trattati
827 estensivamente più avanti.
829 In \nfig\ è riportata la sezione principale del codice del nostro client
830 elementare per il servizio \textit{daytime}, un servizio standard che
831 restituisce l'ora locale della macchina a cui si effettua la richiesta.
833 \begin{figure}[!htbp]
836 #include <sys/types.h> /* predefined types */
837 #include <unistd.h> /* include unix standard library */
838 #include <arpa/inet.h> /* IP addresses conversion utiliites */
839 #include <sys/socket.h> /* socket library */
840 #include <stdio.h> /* include standard I/O library */
842 int main(int argc, char *argv[])
846 struct sockaddr_in serv_add;
847 char buffer[MAXLINE];
850 if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
851 perror("Socket creation error");
854 /* initialize address */
855 memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
856 serv_add.sin_family = AF_INET; /* address type is INET */
857 serv_add.sin_port = htons(13); /* daytime post is 13 */
858 /* build address using inet_pton */
859 if ( (inet_pton(AF_INET, argv[optind], &serv_add.sin_addr)) <= 0) {
860 perror("Address creation error");
863 /* extablish connection */
864 if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
865 perror("Connection error");
868 /* read daytime from server */
869 while ( (nread = read(sock_fd, buffer, MAXLINE)) > 0) {
871 if (fputs(buffer, stdout) == EOF) { /* write daytime */
872 perror("fputs error");
878 perror("Read error");
885 \caption{Esempio di codice di un client elementare per il servizio daytime.}
886 \label{fig:net_cli_code}
889 Il sorgente completo del programma (\texttt{ElemDaytimeTCPClient.c}, che
890 comprende il trattamento delle opzioni e una funzione per stampare un
891 messaggio di aiuto) è allegato alla guida nella sezione dei codici sorgente e
892 può essere compilato su una qualunque macchina Linux.
894 Il programma anzitutto include gli header necessari (\texttt{\small 1--5});
895 dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
896 tutta la parte relativa al trattamento degli argomenti passati dalla linea di
897 comando (effettuata con le apposite routines illustrate in
898 \capref{sec:proc_opt_handling}).
900 Il primo passo (\texttt{\small 14--18}) è creare un \textit{socket} IPv4
901 (\macro{AF\_INET}), di tipo TCP \macro{SOCK\_STREAM}. La funzione
902 \macro{socket} ritorna il descrittore che viene usato per identificare il
903 socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
904 stampa un errore con la relativa routine e si esce.
906 Il passo seguente (\texttt{\small 19--27}) è quello di costruire una apposita
907 struttura \type{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
908 il numero della porta del servizio. Il primo passo è inizializzare tutto a
909 zero, per poi inserire il tipo di protocollo e la porta (usando per
910 quest'ultima la funzione \func{htons} per convertire il formato dell'intero
911 usato dal computer a quello usato nella rete), infine si utilizza la funzione
912 \texttt{inet\_pton} per convertire l'indirizzo numerico passato dalla linea di
915 Usando la funzione \func{connect} sul socket creato in precedenza
916 (\texttt{\small 28--32}) si provvede poi a stabilire la connessione con il
917 server specificato dall'indirizzo immesso nella struttura passata come secondo
918 argomento, il terzo argomento è la dimensione di detta struttura. Dato che
919 esistono diversi tipi di socket, si è dovuto effettuare un cast della
920 struttura inizializzata in precedenza, che è specifica per i socket IPv4. Un
921 valore di ritorno negativo implica il fallimento della connessione.
923 Completata con successo la connessione il passo successivo (\texttt{\small
924 34--40}) è leggere la data dal socket; il server invierà sempre una stringa
925 di 26 caratteri della forma \verb|Wed Apr 4 00:53:00 2001\r\n|, che viene
926 letta dalla funzione \func{read} e scritta su \texttt{stdout}.
928 Dato il funzionamento di TCP la risposta potrà tornare in un unico pacchetto
929 di 26 byte (come avverrà senz'altro nel caso in questione) ma potrebbe anche
930 arrivare in 26 pacchetti di un byte. Per questo nel caso generale non si può
931 mai assumere che tutti i dati arrivino con una singola lettura, pertanto
932 quest'ultima deve essere effettuata in un loop in cui si continui a leggere
933 fintanto che la funzione \func{read} non ritorni uno zero (che significa che
934 l'altro capo ha chiuso la connessione) o un numero minore di zero (che
935 significa un errore nella connessione).
937 Si noti come in questo caso la fine dei dati sia specificata dal server che
938 chiude la connessione; questa è una delle tecniche possibili (è quella usata
939 pure dal protocollo HTTP), ma ce ne possono essere altre, ad esempio FTP marca
940 la conclusione di un blocco di dati con la sequenza ASCII \verb|\r\n|
941 (carriage return e line feed), mentre il DNS mette la lunghezza in testa ad
942 ogni blocco che trasmette. Il punto essenziale è che TCP non provvede nessuna
943 indicazione che permetta di marcare dei blocchi di dati, per cui se questo è
944 necessario deve provvedere il programma stesso.
946 \subsection{Un primo esempio di server}
947 \label{sec:net_serv_sample}
949 Dopo aver illustrato il client daremo anche un esempio di un server
950 elementare, in grado di rispondere al precedente client. Il listato è
951 nuovamente mostrato in \nfig, il sorgente completo
952 (\texttt{ElemDaytimeTCPServer.c}) è allegato insieme agli altri file nella
953 directory \texttt{sources}.
955 \begin{figure}[!htbp]
958 #include <sys/types.h> /* predefined types */
959 #include <unistd.h> /* include unix standard library */
960 #include <arpa/inet.h> /* IP addresses conversion utiliites */
961 #include <sys/socket.h> /* socket library */
962 #include <stdio.h> /* include standard I/O library */
966 int main(int argc, char *argv[])
969 * Variables definition
971 int list_fd, conn_fd;
973 struct sockaddr_in serv_add;
974 char buffer[MAXLINE];
978 if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
979 perror("Socket creation error");
982 /* initialize address */
983 memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
984 serv_add.sin_family = AF_INET; /* address type is INET */
985 serv_add.sin_port = htons(13); /* daytime port is 13 */
986 serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
988 if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
989 perror("bind error");
992 /* listen on socket */
993 if (listen(list_fd, BACKLOG) < 0 ) {
994 perror("listen error");
997 /* write daytime to client */
999 if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
1000 perror("accept error");
1003 timeval = time(NULL);
1004 snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
1005 if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
1006 perror("write error");
1015 \caption{Esempio di codice di un semplice server per il servizio daytime.}
1016 \label{fig:net_serv_code}
1019 Come per il client si includono gli header necessari a cui è aggiunto quello
1020 per trattare i tempi, e si definiscono alcune costanti e le variabili
1021 necessarie in seguito (\texttt{\small 1--18}), come nel caso precedente si
1022 sono omesse le parti relative al trattamento delle opzioni da riga di comando.
1024 La creazione del socket (\texttt{\small 22--26}) è analoga al caso precedente,
1025 come pure l'inizializzazione della struttura \type{sockaddr\_in}, anche in
1026 questo caso si usa la porta standard del servizio daytime, ma come indirizzo
1027 IP si il valore predefinito \macro{INET\_ANY} che corrisponde ad un indirizzo
1028 generico (\texttt{\small 27--31}).
1030 Si effettua poi (\texttt{\small 32--36}) la chiamata alla funzione
1031 \func{bind} che permette di associare la precedente struttura al socket, in
1032 modo che quest'ultimo possa essere usato per accettare connessioni su una
1033 qualunque delle interfacce di rete locali.
1035 Il passo successivo (\texttt{\small 37--41}) è mettere ``in ascolto'' il
1036 socket, questo viene effettuato con la funzione \func{listen} che dice al
1037 kernel di accettare connessioni per il socket specificato, la funzione indica
1038 inoltre, con il secondo parametro, il numero massimo di connessioni che il
1039 kernel accetterà di mettere in coda per il suddetto socket.
1041 Questa ultima chiamata completa la preparazione del socket per l'ascolto (che
1042 viene chiamato anche \textit{listening descriptor}) a questo punto il processo
1043 è mandato in sleep (\texttt{\small 44--47}) con la successiva chiamata alla
1044 funzione \func{accept}, fin quando non arriva e viene accettata una
1045 connessione da un client.
1047 Quando questo avviene \func{accept} ritorna un secondo descrittore di socket,
1048 che viene chiamato \textit{connected descriptor} che è quello che viene usato
1049 dalla successiva chiamata alla \func{write} per scrivere la risposta al
1050 client, una volta che si è opportunamente (\texttt{\small 48--49}) costruita
1051 la stringa con la data da trasmettere. Completata la trasmissione il nuovo
1052 socket viene chiuso (\texttt{\small 54}). Il tutto è inserito in un loop
1053 infinito (\texttt{\small 42--55}) in modo da poter ripetere l'invio della data
1054 ad una successiva connessione.
1056 È importante notare che questo server è estremamente elementare, infatti a
1057 parte il fatto di essere dipendente da IPv4, esso è in grado di servire solo
1058 un client alla volta, è cioè un \textsl{server iterativo}, inoltre esso è
1059 scritto per essere lanciato da linea di comando, se lo si volesse utilizzare
1060 come demone di sistema (che è in esecuzione anche quando non c'è nessuna shell
1061 attiva e il terminale da cui lo si è lanciato è stato sconnesso),
1062 occorrerebbero delle opportune modifiche.