3 %% Copyright (C) 2000-2002 Simone Piccardi. Permission is granted to
4 %% copy, distribute and/or modify this document under the terms of the GNU Free
5 %% Documentation License, Version 1.1 or any later version published by the
6 %% Free Software Foundation; with the Invariant Sections being "Prefazione",
7 %% with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the
8 %% license is included in the section entitled "GNU Free Documentation
11 \chapter{Introduzione ai socket}
12 \label{cha:socket_intro}
14 In questo capitolo inizieremo a spiegare le caratteristiche principali della
15 principale interfaccia per la programmazione di rete, quella dei
16 \textit{socket}, che pur essendo nata in unix è usata ormai da tutti i sistemi
19 Dopo una breve panoramica sulle caratteristiche di questa interfaccia vedremo
20 come creare un socket e come collegarlo allo specifico protocollo di rete che
21 utilizzerà per la comunicazione. Per evitare un'introduzione puramente teorica
22 concluderemo il capitolo con un primo esempio di applicazione.
24 \section{Una panoramica}
25 \label{sec:sock_overview}
27 Iniziamo con una descrizione essenziale di cosa sono i \textit{socket} e di
28 quali sono i concetti fondamentali da tenere presente quando si ha a che fare
31 \subsection{I \textit{socket}}
32 \label{sec:sock_socket_def}
34 Il \textit{socket}\footnote{una traduzione letterale potrebbe essere
35 \textsl{presa}, ma essendo universalmente noti come socket utilizzeremo
36 sempre la parola inglese.} è uno dei principali meccanismi di comunicazione
37 fra programmi utilizzato in ambito Unix. Il socket costituisce in sostanza un
38 canale di comunicazione fra due processi su cui si possono leggere e scrivere
39 dati analogo a quello di una pipe (vedi \secref{sec:ipc_pipes}) ma a
40 differenza di questa e degli altri meccanismi esaminati nel capitolo
41 \capref{cha:IPC} i socket non sono limitati alla comunicazione fra processi
42 che girano sulla stessa macchina ma possono effettuare la comunicazione anche
45 Quella dei socket costituisce infatti la principale API (\textit{Application
46 Program Interface}) usata nella programmazione di rete. La loro origine
47 risale al 1983, quando furono introdotti nel BSD 4.2; l'interfaccia è rimasta
48 sostanzialmente la stessa con piccole modifiche negli anni successivi. Benché
49 siano state sviluppate interfacce alternative, originate dai sistemi SVr4,
50 come la XTI (\textit{X/Open Transport Interface}) nessuna ha mai raggiunto la
51 diffusione e la popolarità di quella dei socket (né tantomeno la stessa
52 usabilità e flessibilità).
54 La flessibilità e la genericità dell'interfaccia inoltre ha consentito di
55 utilizzare i socket con i più disparati meccanismi di comunicazione, e non
56 solo con la suite dei protocolli TCP/IP, che sarà comunque quella di cui
57 tratteremo in maniera più estesa.
60 \subsection{Concetti base}
63 Per capire il funzionamento dei socket occorre avere presente il funzionamento
64 dei protocolli di rete (vedi \capref{cha:network}), ma l'interfaccia è del
65 tutto generale e benché le problematiche (e quindi le modalità di risolvere i
66 problemi) siano diverse a seconda del tipo di protocollo di comunicazione
67 usato, le funzioni da usare restano le stesse.
69 Per questo motivo una semplice descrizione dell'interfaccia è assolutamente
70 inutile, in quanto il comportamento di quest'ultima e le problematiche da
71 affrontare cambiano radicalmente a seconda dello \textsl{stile} di
72 comunicazione usato. La scelta di questo stile va infatti ad incidere sulla
73 semantica che verrà utilizzata a livello utente per gestire la comunicazione
74 (su come inviare e ricevere i dati) e sul comportamento effettivo delle
77 La scelta di uno stile dipende sia dai meccanismi disponibili, sia dal tipo di
78 comunicazione che si vuole effettuare. Ad esempio alcuni stili di
79 comunicazione considerano i dati come una sequenza continua di byte, altri
80 invece li raggruppano in blocchi (i pacchetti).
82 Un'altro esempio di stile concerne la possibilità che la comunicazione possa o
83 meno perdere dati, possa o meno non rispettare l'ordine in cui essi non sono
84 inviati, o inviare dei pacchetti più volte (come nel caso di TCP e UDP).
86 Un terzo esempio di stile di comunicazione concerne le modalità in cui essa
87 avviene, in certi casi essa può essere condotta con una connessione diretta
88 con un solo partner come per una telefonata; altri casi possono prevedere una
89 comunicazione come per lettera, in cui si scrive l'indirizzo su ogni
90 pacchetto, altri ancora una comunicazione \textit{broadcast} come per la
91 radio, in cui i pacchetti vengono emessi su appositi ``canali'' dove chiunque
92 si collega possa riceverli.
94 É chiaro che ciascuno di questi stili comporta una modalità diversa di gestire
95 la comunicazione, ad esempio se è inaffidabile occorrerà essere in grado di
96 gestire la perdita o il rimescolamento dei dati.
99 \section{La creazione di un \textit{socket}}
100 \label{sec:sock_creation}
102 Come accennato l'interfaccia dei socket è estremamente flessibile e permette
103 di interagire con protocolli di comunicazione anche molto diversi fra di loro;
104 in questa sezione vedremo come è possibile creare un socket e come specificare
105 il tipo di comunicazione che esso deve utilizzare.
107 \subsection{La funzione \func{socket}}
108 \label{sec:sock_socket}
110 La creazione di un socket avviene attraverso l'uso della funzione
111 \func{socket}; questa restituisce un \textit{file descriptor}\footnote{del
112 tutto analogo a quelli che si ottengono per i file di dati e le pipe,
113 descritti in \secref{sec:file_fd}.} che serve come riferimento al socket; il
115 \begin{prototype}{sys/socket.h}{int socket(int domain, int type, int protocol)}
119 \bodydesc{La funzione restituisce un intero positivo in caso di successo, e
120 -1 in caso di fallimento, nel qual caso la variabile \var{errno} assumerà
123 \item[\errcode{EPROTONOSUPPORT}] Il tipo di socket o il protocollo scelto non
124 sono supportati nel dominio.
125 \item[\errcode{ENFILE}] Il kernel non ha memoria sufficiente a creare una
126 nuova struttura per il socket.
127 \item[\errcode{EMFILE}] Si è ecceduta la tabella dei file.
128 \item[\errcode{EACCES}] Non si hanno privilegi per creare un socket nel
129 dominio o con il protocollo specificato.
130 \item[\errcode{EINVAL}] Protocollo sconosciuto o dominio non disponibile.
131 \item[\errcode{ENOBUFS}] Non c'è sufficiente memoria per creare il socket
132 (può essere anche \errval{ENOMEM}).
136 La funzione ha tre argomenti, \param{domain} specifica il dominio del socket
137 (definisce cioè la famiglia di protocolli, come vedremo in
138 \secref{sec:sock_domain}), \param{type} specifica il tipo di socket (definisce
139 cioè lo stile di comunicazione, come vedremo in \secref{sec:sock_type}) e
140 \param{protocol} il protocollo; in genere quest'ultimo è indicato
141 implicitamente dal tipo di socket, per cui viene messo a zero (con l'eccezione
142 dei \textit{raw socket}).
144 Si noti che la creazione del socket si limita ad allocare le opportune
145 strutture nel kernel (sostanzialmente una voce nella \textit{file table}) e
146 non comporta nulla riguardo all'indicazione degli indirizzi remoti o locali
147 attraverso i quali si vuole effettuare la comunicazione.
149 \subsection{Il dominio, o \textit{protocol family}}
150 \label{sec:sock_domain}
152 Dati i tanti e diversi protocolli di comunicazione disponibili, esistono vari
153 tipi di socket, che vengono classificati raggruppandoli in quelli che si
154 chiamano \textsl{domini}. La scelta di un dominio equivale in sostanza alla
155 scelta di una famiglia di protocolli. Ciascun dominio ha un suo nome simbolico
156 che convenzionalmente inizia con \texttt{PF\_} da \textit{protocol family},
157 altro nome con cui si indicano i domini.
159 A ciascun tipo di dominio corrisponde un analogo nome simbolico che inizia per
160 \texttt{AF\_} da \textit{address family}, e che identifica il formato degli
161 indirizzi usati in quel dominio; le pagine di manuale di Linux si riferiscono
162 a questi anche come \textit{name space}, (nome che però il manuale delle
163 \acr{glibc} riserva ai domini) e che identifica il formato degli indirizzi
164 usati in quel dominio.
166 L'idea alla base della distinzione era che una famiglia di protocolli potesse
167 supportare vari tipi di indirizzi, per cui il prefisso \texttt{PF\_} si
168 sarebbe dovuto usare nella creazione dei socket e il prefisso \texttt{AF\_} in
169 quello delle strutture degli indirizzi; questo è quanto specificato anche
170 dallo standard POSIX.1g, ma non esistono a tuttora famiglie di protocolli che
171 supportino diverse strutture di indirizzi, per cui nella pratica questi due
172 nomi sono equivalenti e corrispondono agli stessi valori.
174 I domini (e i relativi nomi simbolici), così come i nomi delle famiglie di
175 indirizzi sono definiti dall'header \textit{socket.h}. In Linux le famiglie di
176 protocolli disponibili sono riportate in \tabref{tab:net_pf_names}.
181 \begin{tabular}[c]{|l|l|l|}
183 \textbf{Nome} & \textbf{Utilizzo} &\textbf{Man page} \\
187 \const{PF\_LOCAL} & Local communication & unix(7) \\
188 \const{PF\_INET} & IPv4 Internet protocols & ip(7) \\
189 \const{PF\_INET6} & IPv6 Internet protocols & ipv6(7) \\
190 \const{PF\_IPX} & IPX - Novell protocols & \\
191 \const{PF\_NETLINK}& Kernel user interface device & netlink(7) \\
192 \const{PF\_X25} & ITU-T X.25 / ISO-8208 protocol & x25(7) \\
193 \const{PF\_AX25} & Amateur radio AX.25 protocol & \\
194 \const{PF\_ATMPVC} & Access to raw ATM PVCs & \\
195 \const{PF\_APPLETALK}& Appletalk & ddp(7) \\
196 \const{PF\_PACKET} & Low level packet interface & packet(7) \\
199 \caption{Famiglie di protocolli definiti in Linux}
200 \label{tab:net_pf_names}
203 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
204 esempio in generale tutti i socket di tipo \const{SOCK\_RAW} possono essere
205 creati solo da processi che hanno i privilegi di root (cioè con userid
206 effettivo uguale a zero) o con la capability \texttt{CAP\_NET\_RAW}.
209 \subsection{Il tipo, o stile}
210 \label{sec:sock_type}
212 La scelta di un dominio non comporta però la scelta dello stile di
213 comunicazione, questo infatti viene a dipendere dal protocollo che si andrà ad
214 utilizzare fra quelli disponibili nella famiglia scelta. Le API permettono di
215 scegliere lo stile di comunicazione indicando il tipo di socket; Linux e le
216 \acr{glibc} mettono a disposizione i seguenti tipi di socket (che il manuale
217 della \acr{glibc} chiama \textit{styles}) definiti come \ctyp{int} in
221 \item \const{SOCK\_STREAM} Provvede un canale di trasmissione dati
222 bidirezionale, sequenziale e affidabile. Opera su una connessione con un
223 altro socket. I dati vengono ricevuti e trasmessi come un flusso continuo di
224 byte (da cui il nome \textit{stream}).
225 \item \const{SOCK\_DGRAM} Viene usato per mandare pacchetti di lunghezza
226 massima fissata (\textit{datagram}) indirizzati singolarmente, senza
227 connessione e in maniera non affidabile. È l'opposto del precedente.
228 \item \const{SOCK\_SEQPACKET} Provvede un canale di trasmissione di dati
229 bidirezionale, sequenziale e affidabile. Opera su una connessione con un
230 altro socket. I dati possono solo essere trasmessi e letti per pacchetti (di
231 dimensione massima fissata).
232 \item \const{SOCK\_RAW} Provvede l'accesso a basso livello ai protocolli di
233 rete e alle varie interfacce. I normali programmi di comunicazione non
235 \item \const{SOCK\_RDM} Provvede un canale di trasmissione di pacchetti
236 affidabile ma in cui non è garantito l'ordine di arrivo dei pacchetti.
237 \item \const{SOCK\_PACKET} Obsoleto, non deve essere usato.
240 Si tenga presente che non tutte le combinazioni fra una famiglia di protocolli
241 e un tipo di socket sono valide, in quanto non è detto che in una famiglia
242 esista un protocollo per ciascuno dei diversi stili di comunicazione appena
248 \begin{tabular}{l|c|c|c|c|c|}
249 \multicolumn{1}{c}{} &\multicolumn{1}{c}{\const{SOCK\_STREAM}}&
250 \multicolumn{1}{c}{\const{SOCK\_DGRAM}} &
251 \multicolumn{1}{c}{\const{SOCK\_RAW}} &
252 \multicolumn{1}{c}{\const{SOCK\_PACKET}}&
253 \multicolumn{1}{c}{\const{SOCK\_SEQPACKET}} \\
255 \const{PF\_UNIX} & si & si & & & \\
257 \const{PF\_INET} & TCP & UDP & IPv4 & & \\
259 \const{PF\_INET6} & TCP & UDP & IPv6 & & \\
261 \const{PF\_IPX} & & & & & \\
263 \const{PF\_NETLINK} & & si & si & & \\
265 \const{PF\_X25} & & & & & si \\
267 \const{PF\_AX25} & & & & & \\
269 \const{PF\_ATMPVC} & & & & & \\
271 \const{PF\_APPLETALK} & & si & si & & \\
273 \const{PF\_PACKET} & & si & si & & \\
276 \caption{Combinazioni valide di dominio e tipo di protocollo per la
277 funzione \func{socket}.}
278 \label{tab:sock_sock_valid_combinations}
281 In \secref{tab:sock_sock_valid_combinations} sono mostrate le combinazioni
282 valide possibili per le varie famiglie di protocolli. Per ogni combinazione
283 valida si è indicato il tipo di protocollo, o la parola \textsl{si} qualora
284 non il protocollo non abbia un nome definito, mentre si sono lasciate vuote le
285 caselle per le combinazioni non supportate.
289 \section{Le strutture degli indirizzi dei socket}
290 \label{sec:sock_sockaddr}
292 Come si è visto nella creazione di un socket non si specifica nulla oltre al
293 tipo di famiglia di protocolli che si vuole utilizzare, in particolare nessun
294 indirizzo che identifichi i due capi della comunicazione. La funzione infatti
295 si limita ad allocare nel kernel quanto necessario per poter poi realizzare la
298 Gli indirizzi vengono specificati attraverso apposite strutture che vengono
299 utilizzate dalle altre funzioni della API dei socket quando la comunicazione
300 viene effettivamente realizzata.
302 Ogni famiglia di protocolli ha ovviamente una sua forma di indirizzamento e in
303 corrispondenza a questa una sua peculiare struttura degli indirizzi; i nomi di
304 tutte queste strutture iniziano per \var{sockaddr\_}, quelli propri di
305 ciascuna famiglia vengono identificati dal suffisso finale, aggiunto al nome
309 \subsection{La struttura generica}
310 \label{sec:sock_sa_gen}
312 Le strutture degli indirizzi vengono sempre passate alle varie funzioni
313 attraverso puntatori (cioè \textit{by reference}), ma le funzioni devono poter
314 maneggiare puntatori a strutture relative a tutti gli indirizzi possibili
315 nelle varie famiglie di protocolli; questo pone il problema di come passare
316 questi puntatori, il C ANSI risolve questo problema coi i puntatori generici
317 (i \ctyp{void *}), ma l'interfaccia dei socket è antecedente alla definizione
318 dello standard ANSI, e per questo nel 1982 fu scelto di definire una struttura
319 generica per gli indirizzi dei socket, \type{sockaddr}, che si è riportata in
320 \figref{fig:sock_sa_gen_struct}.
323 \footnotesize \centering
324 \begin{minipage}[c]{15cm}
325 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
327 sa_family_t sa_family; /* address family: AF_xxx */
328 char sa_data[14]; /* address (protocol-specific) */
332 \caption{La struttura generica degli indirizzi dei socket \type{sockaddr}}
333 \label{fig:sock_sa_gen_struct}
336 Tutte le funzioni dei socket che usano gli indirizzi sono definite usando nel
337 prototipo un puntatore a questa struttura; per questo motivo quando si
338 invocano dette funzioni passando l'indirizzo di un protocollo specifico
339 occorrerà eseguire un casting del relativo puntatore.
341 I tipi di dati che compongono la struttura sono stabiliti dallo standard
342 POSIX.1g, riassunti in \tabref{tab:sock_data_types} con i rispettivi file di
343 include in cui sono definiti; la struttura è invece definita nell'include file
349 \begin{tabular}{|l|l|l|}
351 \multicolumn{1}{|c|}{\textbf{Tipo}}&
352 \multicolumn{1}{|c|}{\textbf{Descrizione}}&
353 \multicolumn{1}{|c|}{\textbf{Header}} \\
356 \type{int8\_t} & intero a 8 bit con segno & \file{sys/types.h}\\
357 \type{uint8\_t} & intero a 8 bit senza segno & \file{sys/types.h}\\
358 \type{int16\_t} & intero a 16 bit con segno & \file{sys/types.h}\\
359 \type{uint16\_t} & intero a 16 bit senza segno& \file{sys/types.h}\\
360 \type{int32\_t} & intero a 32 bit con segno & \file{sys/types.h}\\
361 \type{uint32\_t} & intero a 32 bit senza segno& \file{sys/types.h}\\
363 \type{sa\_family\_t} & famiglia degli indirizzi& \file{sys/socket.h}\\
364 \type{socklen\_t} & lunghezza (\type{uint32\_t}) dell'indirizzo di
365 un socket& \file{sys/socket.h}\\
367 \type{in\_addr\_t} & indirizzo IPv4 (\type{uint32\_t}) &
368 \file{netinet/in.h}\\
369 \type{in\_port\_t} & porta TCP o UDP (\type{uint16\_t})&
370 \file{netinet/in.h}\\
373 \caption{Tipi di dati usati nelle strutture degli indirizzi, secondo quanto
374 stabilito dallo standard POSIX.1g.}
375 \label{tab:sock_data_types}
378 In alcuni sistemi la struttura è leggermente diversa e prevede un primo membro
379 aggiuntivo \var{uint8\_t sin\_len} (come riportato da R. Stevens nei suoi
380 libri). Questo campo non verrebbe usato direttamente dal programmatore e non è
381 richiesto dallo standard POSIX.1g, in Linux pertanto non esiste. Il campo
382 \type{sa\_family\_t} era storicamente un \ctyp{unsigned short}.
384 Dal punto di vista del programmatore l'unico uso di questa struttura è quello
385 di fare da riferimento per il casting, per il kernel le cose sono un po'
386 diverse, in quanto esso usa il puntatore per recuperare il campo
387 \var{sa\_family} con cui determinare il tipo di indirizzo; per questo
388 motivo, anche se l'uso di un puntatore \ctyp{void *} sarebbe più immediato
389 per l'utente (che non dovrebbe più eseguire il casting), è stato mantenuto
390 l'uso di questa struttura.
393 \subsection{La struttura degli indirizzi IPv4}
394 \label{sec:sock_sa_ipv4}
396 I socket di tipo \const{PF\_INET} vengono usati per la comunicazione
397 attraverso internet; la struttura per gli indirizzi per un socket internet
398 (IPv4) è definita come \type{sockaddr\_in} nell'header file
399 \file{netinet/in.h} e secondo le pagine di manuale ha la forma mostrata in
400 \figref{fig:sock_sa_ipv4_struct}, conforme allo standard POSIX.1g.
403 \footnotesize\centering
404 \begin{minipage}[c]{15cm}
405 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
407 sa_family_t sin_family; /* address family: AF_INET */
408 u_int16_t sin_port; /* port in network byte order */
409 struct in_addr sin_addr; /* internet address */
411 /* Internet address. */
413 u_int32_t s_addr; /* address in network byte order */
417 \caption{La struttura degli indirizzi dei socket internet (IPv4)
418 \type{sockaddr\_in}.}
419 \label{fig:sock_sa_ipv4_struct}
422 L'indirizzo di un socket internet (secondo IPv4) comprende l'indirizzo
423 internet di un'interfaccia più un numero di porta. Il protocollo IP non
424 prevede numeri di porta, che sono utilizzati solo dai protocolli di livello
425 superiore come TCP e UDP. Questa struttura però viene usata anche per i socket
426 RAW che accedono direttamente al livello di IP, nel qual caso il numero della
427 porta viene impostato al numero di protocollo.
429 Il membro \var{sin\_family} deve essere sempre impostato; \var{sin\_port}
430 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
431 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
432 servizi standard. Soltanto processi con i privilegi di root (con userid
433 effettivo uguale a zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE}
434 possono usare la funzione \func{bind} su queste porte.
436 Il membro \var{sin\_addr} contiene l'indirizzo internet dell'altro capo
437 della comunicazione, e viene acceduto sia come struttura (un resto di una
438 implementazione precedente in cui questa era una \texttt{union} usata per
439 accedere alle diverse classi di indirizzi) che come intero.
441 Infine è da sottolineare che sia gli indirizzi che i numeri di porta devono
442 essere specificati in quello che viene chiamato \textit{network order}, cioè
443 con i bit ordinati in formato \textit{big endian}, questo comporta la
444 necessità di usare apposite funzioni di conversione per mantenere la
445 portabilità del codice (vedi \secref{sec:sock_addr_func} per i dettagli del
446 problema e le relative soluzioni).
449 \subsection{La struttura degli indirizzi IPv6}
450 \label{sec:sock_sa_ipv6}
452 Essendo IPv6 un'estensione di IPv4 i socket di tipo \const{PF\_INET6} sono
453 sostanzialmente identici ai precedenti; la parte in cui si trovano
454 praticamente tutte le differenze è quella della struttura degli indirizzi. La
455 struttura degli indirizzi è definita ancora in \file{netinet/in.h}.
458 \footnotesize \centering
459 \begin{minipage}[c]{15cm}
460 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
461 struct sockaddr_in6 {
462 u_int16_t sin6_family; /* AF_INET6 */
463 u_int16_t sin6_port; /* port number */
464 u_int32_t sin6_flowinfo; /* IPv6 flow information */
465 struct in6_addr sin6_addr; /* IPv6 address */
466 u_int32_t sin6_scope_id; /* Scope id (new in 2.4) */
470 unsigned char s6_addr[16]; /* IPv6 address */
474 \caption{La struttura degli indirizzi dei socket IPv6
475 \type{sockaddr\_in6}.}
476 \label{fig:sock_sa_ipv6_struct}
479 Il campo \var{sin6\_family} deve essere sempre impostato ad
480 \const{AF\_INET6}, il campo \var{sin6\_port} è analogo a quello di IPv4 e
481 segue le stesse regole; il campo \var{sin6\_flowinfo} è a sua volta diviso
482 in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
483 successivi 4 bit la priorità e gli ultimi 4 sono riservati; questi valori
484 fanno riferimento ad alcuni campi specifici dell'header dei pacchetti IPv6
485 (vedi \secref{sec:IP_ipv6head}) ed il loro uso è sperimentale.
487 Il campo \var{sin6\_addr} contiene l'indirizzo a 128 bit usato da IPv6,
488 infine il campo \var{sin6\_scope\_id} è un campo introdotto con il kernel
489 2.4 per gestire alcune operazioni riguardanti il multicasting.
491 Si noti che questa struttura è più grande di una \var{sockaddr} generica,
492 quindi occorre stare attenti a non avere fatto assunzioni riguardo alla
493 possibilità di contenere i dati nelle dimensioni di quest'ultima.
496 \subsection{La struttura degli indirizzi locali}
497 \label{sec:sock_sa_local}
499 I socket di tipo \const{PF\_UNIX} o \const{PF\_LOCAL} vengono usati per una
500 comunicazione fra processi che stanno sulla stessa macchina (per vengono
501 chiamati \textit{local domain} o anche \textit{Unix domain}); essi rispetto ai
502 precedenti possono essere anche creati in maniera anonima attraverso la
503 funzione \func{socketpair} (vedi \secref{sec:ipc_socketpair}). Quando però si
504 vuole fare riferimento esplicito ad uno di questi socket si deve usare la
505 seguente struttura di indirizzi definita nel file di header \file{sys/un.h}.
508 \footnotesize \centering
509 \begin{minipage}[c]{15cm}
510 \begin{lstlisting}[labelstep=0]{}%,frame=,indent=1cm]{}
511 #define UNIX_PATH_MAX 108
513 sa_family_t sun_family; /* AF_UNIX */
514 char sun_path[UNIX_PATH_MAX]; /* pathname */
518 \caption{La struttura degli indirizzi dei socket locali
520 \label{fig:sock_sa_local_struct}
523 In questo caso il campo \var{sun\_family} deve essere \const{AF\_UNIX},
524 mentre il campo \var{sun\_path} deve specificare un indirizzo; questo ha
525 due forme un file (di tipo socket) nel filesystem o una stringa univoca
526 (tenuta in uno spazio di nomi astratto). Nel primo caso l'indirizzo viene
527 specificato come una stringa (terminata da uno zero) corrispondente al
528 pathname del file; nel secondo invece \var{sun\_path} inizia con uno zero
529 vengono usati i restanti byte come stringa (senza terminazione).
532 % \subsection{Il passaggio delle strutture}
533 % \label{sec:sock_addr_pass}
535 % Come detto nelle funzioni della API dei socket le strutture degli indirizzi
536 % vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
537 % della struttura è passata come argomento, ma in questo caso la modalità del
538 % passaggio dipende dalla direzione del medesimo, dal processo al kernel o
541 % In particolare le tre funzioni \texttt{bind}, \texttt{connect} e
542 % \texttt{sendto} passano la struttura al kernel, in questo caso è passata
543 % \textsl{per valore} anche la dimensione della medesima
546 % Le funzioni \texttt{accept}, \texttt{recvfrom}, \texttt{getsockname} e
547 % \texttt{getpeername} invece ricevono i valori del kernel
551 \section{Le funzioni di conversione degli indirizzi}
552 \label{sec:sock_addr_func}
554 In questa sezione tratteremo delle varie funzioni usate per manipolare gli
555 indirizzi, limitandoci però agli indirizzi internet.
557 Come accennato gli indirizzi e i numeri di porta usati nella rete devono
558 essere forniti in formato opportuno (il \textit{network order}). Per capire
559 cosa significa tutto ciò occorre introdurre un concetto generale che tornerà
560 utile anche in seguito.
563 \subsection{La \textit{endianess}}
564 \label{sec:sock_endianess}
566 La rappresentazione di un numero binario in un computer può essere fatta in
567 due modi, chiamati rispettivamente \textit{big endian} e \textit{little
568 endian} a seconda di come i singoli bit vengono aggregati per formare le
569 variabili intere (in diretta corrispondenza a come sono poi in realtà cablati
570 sui bus interni del computer).
572 Per capire meglio il problema si consideri un intero a 16 bit scritto in una
573 locazione di memoria posta ad un certo indirizzo. I singoli bit possono essere
574 disposti un memoria in due modi, a partire dal più significativo o a partire
575 dal meno significativo. Così nel primo caso si troverà il byte che contiene i
576 bit più significativi all'indirizzo menzionato e il byte con i bit meno
577 significativi nell'indirizzo successivo; questo ordinamento è detto
578 \textit{little endian} dato che il dato finale è la parte ``piccola'' del
579 numero. Il caso opposto, in cui si parte dal bit meno significativo è detto
580 per lo stesso motivo \textit{big endian}.
582 La \textit{endianess} di un computer dipende essenzialmente dalla architettura
583 hardware usata; Intel e Digital usano il \textit{little endian}, Motorola,
584 IBM, Sun (sostanzialmente tutti gli altri) usano il \textit{big endian}. Il
585 formato della rete è anch'esso \textit{big endian}, altri esempi sono quello
586 del bus PC, che è \textit{little endian}, o quello del bus VME che è
589 Esistono poi anche dei processori che possono scegliere il tipo di formato
590 all'avvio e alcuni che, come il PowerPC o l'Intel i860, possono pure passare
591 da un tipo di ordinamento all'altro con una specifica istruzione. In ogni caso
592 in Linux l'ordinamento è definito dall'architettura e dopo l'avvio del sistema
593 resta sempre lo stesso, anche quando il processore permetterebbe di eseguire
596 \subsection{Le funzioni per il riordinamento}
597 \label{sec:sock_func_ord}
599 Il problema connesso all'endianess è che quando si passano dei dati da un tipo
600 di architettura all'altra i dati vengono interpretati in maniera diversa, e ad
601 esempio nel caso dell'intero a 16 bit ci si ritroverà con i due byte in cui è
602 suddiviso scambiati di posto, e ne sarà quindi invertito l'ordine di lettura
603 per cui, per riavere il valore originale dovranno essere rovesciati.
605 Per questo motivo si usano le seguenti funzioni di conversione che servono a
606 tener conto automaticamente della possibile differenza fra l'ordinamento usato
607 sul computer e quello che viene usato nelle trasmissione sulla rete; queste
610 \headdecl{netinet/in.h}
611 \funcdecl{unsigned long int htonl(unsigned long int hostlong)}
612 Converte l'intero a 32 bit \var{hostlong} dal formato della macchina a
615 \funcdecl{unsigned short int htons(unsigned short int hostshort)}
616 Converte l'intero a 16 bit \var{hostshort} dal formato della macchina a
619 \funcdecl{unsigned long int ntonl(unsigned long int netlong)}
620 Converte l'intero a 32 bit \var{netlong} dal formato della rete a quello
623 \funcdecl{unsigned sort int ntons(unsigned short int netshort)}
624 Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello
627 \bodydesc{Tutte le funzioni restituiscono il valore convertito, e non hanno
631 I nomi sono assegnati usando la lettera \texttt{n} come mnemonico per indicare
632 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera
633 \texttt{h} come mnemonico per l'ordinamento usato sulla macchina locale (da
634 \textit{host order}), mentre le lettere \texttt{s} e \texttt{l} stanno ad
635 indicare i tipi di dato (\ctyp{long} o \ctyp{short}, riportati anche dai
638 Usando queste funzioni si ha la conversione automatica: nel caso in cui la
639 macchina che si sta usando abbia una architettura \textit{big endian} queste
640 funzioni sono definite come macro che non fanno nulla. Per questo motivo vanno
641 sempre utilizzate, anche quando potrebbero non essere necessarie, in modo da
642 assicurare la portabilità del codice su tutte le architetture.
645 \subsection{Le funzioni \func{inet\_aton}, \func{inet\_addr} e
647 \label{sec:sock_func_ipv4}
649 Un secondo insieme di funzioni di manipolazione serve per passare dal formato
650 binario usato nelle strutture degli indirizzi alla rappresentazione dei numeri
651 IP che si usa normalmente.
653 Le prime tre funzioni di manipolazione riguardano la conversione degli
654 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
655 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
656 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network
657 order}) e viceversa; in questo caso si usa la lettera \texttt{a} come
658 mnemonico per indicare la stringa. Dette funzioni sono:
659 \begin{prototype}{arpa/inet.h}
660 {int inet\_aton(const char *src, struct in\_addr *dest)}
661 Converte la stringa puntata da \var{src} nell'indirizzo binario da
662 memorizzare all'indirizzo puntato da \var{dest}, restituendo 0 in caso di
663 successo e 1 in caso di fallimento (è espressa in questa forma in modo da
664 poterla usare direttamente con il puntatore usato per passare la struttura
665 degli indirizzi). Se usata con \var{dest} inizializzato a \val{NULL}
666 effettua la validazione dell'indirizzo.
668 \begin{prototype}{arpa/inet.h}{in\_addr\_t inet\_addr(const char *strptr)}
669 Restituisce l'indirizzo a 32 bit in network order a partire dalla stringa
670 passata come parametro, in caso di errore restituisce il valore
671 \const{INADDR\_NONE} che tipicamente sono trentadue bit a uno; questo
672 comporta che la stringa \texttt{255.255.255.255}, che pure è un indirizzo
673 valido, non può essere usata con questa funzione; per questo motivo essa è
674 generalmente deprecata in favore della precedente.
676 \begin{prototype}{arpa/inet.h}{char *inet\_ntoa(struct in\_addr addrptr)}
677 Converte il valore a 32 bit dell'indirizzo (espresso in \textit{network
678 order}) restituendo il puntatore alla stringa che contiene l'espressione
679 in formato dotted decimal. Si deve tenere presente che la stringa risiede in
680 memoria statica, per cui questa funzione non è rientrante.
684 \subsection{Le funzioni \func{inet\_pton} e \func{inet\_ntop}}
685 \label{sec:sock_conv_func_gen}
687 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
688 motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e
689 \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in
690 questo caso le lettere \texttt{n} e \texttt{p} sono degli mnemonici per
691 ricordare il tipo di conversione effettuata e stanno per \textit{presentation}
694 % \begin{figure}[htb]
697 % \caption{Schema della rappresentazioni utilizzate dalle funzioni di
698 % conversione \texttt{inet\_pton} e \texttt{inet\_ntop} }
699 % \label{fig:sock_inet_conv_func}
703 Entrambe le funzioni accettano l'argomento \param{af} che indica il tipo di
704 indirizzo e può essere soltanto \const{AF\_INET} o \const{AF\_INET6}. I
705 prototipi delle suddette funzioni sono i seguenti:
706 \begin{prototype}{sys/socket.h}
707 {int inet\_pton(int af, const char *src, void *addr\_ptr)}
709 Converte l'indirizzo espresso tramite una stringa nel valore numerico.
711 \bodydesc{La funzione restituisce un valore negativo se \var{af} specifica
712 una famiglia di indirizzi non valida, settando \var{errno} a
713 \errcode{EAFNOSUPPORT}, un valore nullo se \param{src} non rappresenta un
714 indirizzo valido, ed un valore positivo in caso di successo.}
717 La funzione converte la stringa indicata tramite \param{src} nel valore
718 numerico dell'indirizzo IP del tipo specificato da \param{af} che viene
719 memorizzato all'indirizzo puntato da \var{addr\_ptr}, la funzione restituisce
720 un valore positivo in caso di successo, e zero se la stringa non rappresenta
721 un indirizzo valido, e negativo se \var{af} specifica una famiglia di
722 indirizzi non valida.
725 \begin{prototype}{sys/socket.h}
726 {char *inet\_ntop(int af, const void *addr\_ptr, char *dest, size\_t len)}
727 Converte la struttura dell'indirizzo puntata da \var{addr\_ptr} in una
728 stringa che viene copiata nel buffer puntato dall'indirizzo \var{dest};
729 questo deve essere preallocato dall'utente e la lunghezza deve essere almeno
730 \const{INET\_ADDRSTRLEN} in caso di indirizzi IPv4 e
731 \const{INET6\_ADDRSTRLEN} per indirizzi IPv6; la lunghezza del buffer deve
732 comunque venire specificata attraverso il parametro \var{len}.
734 \bodydesc{La funzione restituisce un puntatore non nullo a \var{dest} in
735 caso di successo e un puntatore nullo in caso di fallimento, in
736 quest'ultimo caso viene impostata la variabile \var{errno} con il valore
737 \errval{ENOSPC} in caso le dimensioni dell'indirizzo eccedano la lunghezza
738 specificata da \var{len} o \errval{ENOAFSUPPORT} in caso \var{af} non sia
739 una famiglia di indirizzi valida.}
742 Gli indirizzi vengono convertiti da/alle rispettive strutture di indirizzo
743 (\var{struct in\_addr} per IPv4, e \var{struct in6\_addr} per IPv6), che
744 devono essere precedentemente allocate e passate attraverso il puntatore
745 \var{addr\_ptr}; il parametro \var{dest} di \func{inet\_ntop} non può essere
746 nullo e deve essere allocato precedentemente.
748 Il formato usato per gli indirizzi in formato di presentazione è la notazione
749 \textit{dotted decimal} per IPv4 e quella descritta in
750 \secref{sec:IP_ipv6_notation} per IPv6.
754 \section{Un esempio di applicazione}
755 \label{sec:sock_appplication}
757 Per evitare di rendere questa introduzione ai socket puramente teorica
758 iniziamo con il mostrare un esempio di un client TCP elementare. Prima di
759 passare agli esempi del client e del server, esamineremo una caratteristica
760 delle funzioni di I/O sui socket che ci tornerà utile anche in seguito.
763 \subsection{Il comportamento delle funzioni di I/O}
764 \label{sec:sock_io_behav}
766 Una cosa di cui non sempre si è consapevoli quando si ha a che fare con i
767 socket è che le funzioni di input/output non sempre hanno lo stesso
768 comportamento che avrebbero con i normali files (in particolare questo accade
769 per i socket di tipo stream).
771 Infatti con i socket è comune che funzioni come \func{read} o \func{write}
772 possano restituire in input o scrivere in output un numero di byte minore di
773 quello richiesto. Come già accennato in \secref{sec:file_read} questo è un
774 comportamento normale anche per l'I/O su file, e succede
775 perché si eccede in lettura o scrittura il limite di buffer del kernel.
777 In questo caso tutto quello che il programma chiamante deve fare è di ripetere
778 la lettura (o scrittura) per la quantità di byte rimanenti (lo stesso può
779 avvenire scrivendo più di 4096 byte in una pipe, dato che quello è il limite
780 di solito adottato per il buffer di trasmissione del kernel).
788 ssize_t SockRead(int fd, void *buf, size_t count)
794 while (nleft > 0) { /* repeat until no left */
795 if ( (nread = read(fd, buf, nleft)) < 0) {
796 if (errno == EINTR) { /* if interrupted by system call */
797 continue; /* repeat the loop */
799 return(nread); /* otherwise exit */
801 } else if (nread == 0) { /* EOF */
802 break; /* break loop here */
804 nleft -= nread; /* set left to read */
805 buf +=nread; /* set pointer */
807 return (count - nleft);
810 \caption{Funzione \func{SockRead}, legge \var{count} byte da un socket }
811 \label{fig:sock_SockRead_code}
814 Per questo motivo seguendo l'esempio di W. R. Stevens si sono definite due
815 funzioni \func{SockRead} e \func{SockWrite} che eseguono la lettura da un
816 socket tenendo conto di questa caratteristica, ed in grado di ritornare dopo
817 avere letto o scritto esattamente il numero di byte specificato; il sorgente è
818 riportato in \figref{fig:sock_SockRead_code} e
819 \figref{fig:sock_SockWrite_code} ed è disponibile fra i sorgenti allegati alla
820 guida nei files \file{SockRead.c} e \file{SockWrite.c}.
828 ssize_t SockWrite(int fd, const void *buf, size_t count)
834 while (nleft > 0) { /* repeat until no left */
835 if ( (nwritten = write(fd, buf, nleft)) < 0) {
836 if (errno == EINTR) { /* if interrupted by system call */
837 continue; /* repeat the loop */
839 return(nwritten); /* otherwise exit with error */
842 nleft -= nwritten; /* set left to write */
843 buf +=nwritten; /* set pointer */
848 \caption{Funzione \func{SockWrite}, scrive \var{count} byte su un socket }
849 \label{fig:sock_SockWrite_code}
852 Come si può notare le funzioni ripetono la lettura/scrittura in un ciclo fino
853 all'esaurimento del numero di byte richiesti, in caso di errore viene
854 controllato se questo è \errcode{EINTR} (cioè un'interruzione della system call
855 dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
856 l'errore viene ritornato interrompendo il ciclo.
858 Nel caso della lettura, se il numero di byte letti è zero, significa che si è
859 arrivati alla fine del file e pertanto si ritorna senza aver concluso la
860 lettura di tutti i byte richiesti.
864 \subsection{Un primo esempio di client}
865 \label{sec:net_cli_sample}
867 Lo scopo di questo esempio è fornire un primo approccio alla programmazione di
868 rete e vedere come si usano le funzioni descritte in precedenza, alcune delle
869 funzioni usate nell'esempio saranno trattate in dettaglio nel capitolo
870 successivo; qui ci limiteremo a introdurre la nomenclatura senza fornire
871 definizioni precise e dettagli di funzionamento che saranno trattati
872 estensivamente più avanti.
874 In \figref{fig:net_cli_code} è riportata la sezione principale del codice del
875 nostro client elementare per il servizio \textit{daytime}, un servizio
876 standard che restituisce l'ora locale della macchina a cui si effettua la
882 #include <sys/types.h> /* predefined types */
883 #include <unistd.h> /* include unix standard library */
884 #include <arpa/inet.h> /* IP addresses conversion utilities */
885 #include <sys/socket.h> /* socket library */
886 #include <stdio.h> /* include standard I/O library */
888 int main(int argc, char *argv[])
892 struct sockaddr_in serv_add;
893 char buffer[MAXLINE];
896 if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
897 perror("Socket creation error");
900 /* initialize address */
901 memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
902 serv_add.sin_family = AF_INET; /* address type is INET */
903 serv_add.sin_port = htons(13); /* daytime post is 13 */
904 /* build address using inet_pton */
905 if ( (inet_pton(AF_INET, argv[optind], &serv_add.sin_addr)) <= 0) {
906 perror("Address creation error");
909 /* extablish connection */
910 if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
911 perror("Connection error");
914 /* read daytime from server */
915 while ( (nread = read(sock_fd, buffer, MAXLINE)) > 0) {
917 if (fputs(buffer, stdout) == EOF) { /* write daytime */
918 perror("fputs error");
924 perror("Read error");
931 \caption{Esempio di codice di un client elementare per il servizio daytime.}
932 \label{fig:net_cli_code}
935 Il sorgente completo del programma (\file{ElemDaytimeTCPClient.c}, che
936 comprende il trattamento delle opzioni e una funzione per stampare un
937 messaggio di aiuto) è allegato alla guida nella sezione dei codici sorgente e
938 può essere compilato su una qualunque macchina Linux.
940 Il programma anzitutto include gli header necessari (\texttt{\small 1--5});
941 dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
942 tutta la parte relativa al trattamento degli argomenti passati dalla linea di
943 comando (effettuata con le apposite routine illustrate in
944 \capref{sec:proc_opt_handling}).
946 Il primo passo (\texttt{\small 14--18}) è creare un \textit{socket} IPv4
947 (\const{AF\_INET}), di tipo TCP \const{SOCK\_STREAM}. La funzione
948 \const{socket} ritorna il descrittore che viene usato per identificare il
949 socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
950 stampa un errore con la relativa routine e si esce.
952 Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
953 struttura \type{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
954 il numero della porta del servizio. Il primo passo è inizializzare tutto a
955 zero, per poi inserire il tipo di protocollo e la porta (usando per
956 quest'ultima la funzione \func{htons} per convertire il formato dell'intero
957 usato dal computer a quello usato nella rete), infine si utilizza la funzione
958 \func{inet\_pton} per convertire l'indirizzo numerico passato dalla linea di
961 Usando la funzione \func{connect} sul socket creato in precedenza
962 (\texttt{\small 28--32}) si provvede poi a stabilire la connessione con il
963 server specificato dall'indirizzo immesso nella struttura passata come secondo
964 argomento, il terzo argomento è la dimensione di detta struttura. Dato che
965 esistono diversi tipi di socket, si è dovuto effettuare un cast della
966 struttura inizializzata in precedenza, che è specifica per i socket IPv4. Un
967 valore di ritorno negativo implica il fallimento della connessione.
969 Completata con successo la connessione il passo successivo (\texttt{\small
970 34--40}) è leggere la data dal socket; il server invierà sempre una stringa
971 di 26 caratteri della forma \verb|Wed Apr 4 00:53:00 2001\r\n|, che viene
972 letta dalla funzione \func{read} e scritta su \file{stdout}.
974 Dato il funzionamento di TCP la risposta potrà tornare in un unico pacchetto
975 di 26 byte (come avverrà senz'altro nel caso in questione) ma potrebbe anche
976 arrivare in 26 pacchetti di un byte. Per questo nel caso generale non si può
977 mai assumere che tutti i dati arrivino con una singola lettura, pertanto
978 quest'ultima deve essere effettuata in un ciclo in cui si continui a leggere
979 fintanto che la funzione \func{read} non ritorni uno zero (che significa che
980 l'altro capo ha chiuso la connessione) o un numero minore di zero (che
981 significa un errore nella connessione).
983 Si noti come in questo caso la fine dei dati sia specificata dal server che
984 chiude la connessione; questa è una delle tecniche possibili (è quella usata
985 pure dal protocollo HTTP), ma ce ne possono essere altre, ad esempio FTP marca
986 la conclusione di un blocco di dati con la sequenza ASCII \verb|\r\n|
987 (carriage return e line feed), mentre il DNS mette la lunghezza in testa ad
988 ogni blocco che trasmette. Il punto essenziale è che TCP non provvede nessuna
989 indicazione che permetta di marcare dei blocchi di dati, per cui se questo è
990 necessario deve provvedere il programma stesso.
992 \subsection{Un primo esempio di server}
993 \label{sec:net_serv_sample}
995 Dopo aver illustrato il client daremo anche un esempio di un server
996 elementare, in grado di rispondere al precedente client. Il listato è
997 nuovamente mostrato in \figref{fig:net_serv_code}, il sorgente completo
998 (\file{ElemDaytimeTCPServer.c}) è allegato insieme agli altri file nella
999 directory \file{sources}.
1001 \begin{figure}[!htbp]
1003 \begin{lstlisting}{}
1004 #include <sys/types.h> /* predefined types */
1005 #include <unistd.h> /* include unix standard library */
1006 #include <arpa/inet.h> /* IP addresses conversion utilities */
1007 #include <sys/socket.h> /* socket library */
1008 #include <stdio.h> /* include standard I/O library */
1012 int main(int argc, char *argv[])
1015 * Variables definition
1017 int list_fd, conn_fd;
1019 struct sockaddr_in serv_add;
1020 char buffer[MAXLINE];
1024 if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
1025 perror("Socket creation error");
1028 /* initialize address */
1029 memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
1030 serv_add.sin_family = AF_INET; /* address type is INET */
1031 serv_add.sin_port = htons(13); /* daytime port is 13 */
1032 serv_add.sin_addr.s_addr = htonl(INADDR_ANY); /* connect from anywhere */
1034 if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
1035 perror("bind error");
1038 /* listen on socket */
1039 if (listen(list_fd, BACKLOG) < 0 ) {
1040 perror("listen error");
1043 /* write daytime to client */
1045 if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
1046 perror("accept error");
1049 timeval = time(NULL);
1050 snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
1051 if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
1052 perror("write error");
1061 \caption{Esempio di codice di un semplice server per il servizio daytime.}
1062 \label{fig:net_serv_code}
1065 Come per il client si includono gli header necessari a cui è aggiunto quello
1066 per trattare i tempi, e si definiscono alcune costanti e le variabili
1067 necessarie in seguito (\texttt{\small 1--18}), come nel caso precedente si
1068 sono omesse le parti relative al trattamento delle opzioni da riga di comando.
1070 La creazione del socket (\texttt{\small 22--26}) è analoga al caso precedente,
1071 come pure l'inizializzazione della struttura \type{sockaddr\_in}, anche in
1072 questo caso si usa la porta standard del servizio daytime, ma come indirizzo
1073 IP si il valore predefinito \const{INET\_ANY} che corrisponde ad un indirizzo
1074 generico (\texttt{\small 27--31}).
1076 Si effettua poi (\texttt{\small 32--36}) la chiamata alla funzione
1077 \func{bind} che permette di associare la precedente struttura al socket, in
1078 modo che quest'ultimo possa essere usato per accettare connessioni su una
1079 qualunque delle interfacce di rete locali.
1081 Il passo successivo (\texttt{\small 37--41}) è mettere ``in ascolto'' il
1082 socket, questo viene effettuato con la funzione \func{listen} che dice al
1083 kernel di accettare connessioni per il socket specificato, la funzione indica
1084 inoltre, con il secondo parametro, il numero massimo di connessioni che il
1085 kernel accetterà di mettere in coda per il suddetto socket.
1087 Questa ultima chiamata completa la preparazione del socket per l'ascolto (che
1088 viene chiamato anche \textit{listening descriptor}) a questo punto il processo
1089 è mandato in sleep (\texttt{\small 44--47}) con la successiva chiamata alla
1090 funzione \func{accept}, fin quando non arriva e viene accettata una
1091 connessione da un client.
1093 Quando questo avviene \func{accept} ritorna un secondo descrittore di socket,
1094 che viene chiamato \textit{connected descriptor} che è quello che viene usato
1095 dalla successiva chiamata alla \func{write} per scrivere la risposta al
1096 client, una volta che si è opportunamente (\texttt{\small 48--49}) costruita
1097 la stringa con la data da trasmettere. Completata la trasmissione il nuovo
1098 socket viene chiuso (\texttt{\small 54}). Il tutto è inserito in un ciclo
1099 infinito (\texttt{\small 42--55}) in modo da poter ripetere l'invio della data
1100 ad una successiva connessione.
1102 È importante notare che questo server è estremamente elementare, infatti a
1103 parte il fatto di essere dipendente da IPv4, esso è in grado di servire solo
1104 un client alla volta, è cioè un \textsl{server iterativo}, inoltre esso è
1105 scritto per essere lanciato da linea di comando, se lo si volesse utilizzare
1106 come demone di sistema (che è in esecuzione anche quando non c'è nessuna shell
1107 attiva e il terminale da cui lo si è lanciato è stato sconnesso),
1108 occorrerebbero delle opportune modifiche.
1110 %%% Local Variables:
1112 %%% TeX-master: "gapil"