Correzione ai limiti, aggiustate referenze e iniziato le funzioni per
[gapil.git] / socket.tex
1 \chapter{Introduzione ai socket}
2 \label{cha:socket_intro}
3
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
7 operativi.
8
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 un'introduzione puramente teorica
12 concluderemo il capitolo con un primo esempio di applicazione.
13
14 \section{Una panoramica}
15 \label{sec:sock_overview}
16
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
19 con essi.
20
21 \subsection{I \textit{socket}}
22 \label{sec:sock_socket_def}
23
24 Il \textit{socket}\footnote{una traduzione letterale potrebbe essere
25   \textsl{presa}, 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.
33
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 SVr4,
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
41 flessibilità).
42
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.
47
48
49 \subsection{Concetti base}
50 \label{sec:sock_gen}
51
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.
57
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
64 utilizzate.
65
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 byte, altri
69 invece li raggruppano in blocchi (i pacchetti).
70
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).
74
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.
82
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.
86
87
88 \section{La creazione di un \textit{socket}}
89 \label{sec:sock_creation}
90
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.
95
96 \subsection{La funzione \func{socket}}
97 \label{sec:sock_socket}
98
99 La creazione di un socket avviene attraverso l'uso della funzione
100 \func{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
105 verificare!]).
106
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}).
112
113 \begin{prototype}{sys/socket.h}{int socket(int domain, int type, int protocol)}
114
115   Apre un socket.
116   
117   \bodydesc{La funzione restituisce un intero positivo se riesce, e -1 se
118     fallisce, in quest'ultimo caso la variabile \var{errno} è settata con i
119     seguenti codici di errore:
120
121   \begin{errlist}
122   \item[\macro{EPROTONOSUPPORT}] Il tipo di socket o il protocollo scelto non
123     sono supportati nel dominio.
124   \item[\macro{ENFILE}] Il kernel non ha memoria sufficiente a creare una
125     nuova struttura per il socket.
126   \item[\macro{EMFILE}] Si è ecceduta la tabella dei file.
127   \item[\macro{EACCES}] Non si hanno privilegi per creare un socket nel
128     dominio o con il protocollo specificato.
129   \item[\macro{EINVAL}] Protocollo sconosciuto o dominio non disponibile.
130   \item[\macro{ENOBUFS}] Non c'è sufficiente memoria per creare il socket (può
131     essere anche \macro{ENOMEM}).
132   \end{errlist}}
133 \end{prototype}
134
135 Si noti che la creazione del socket non comporta nulla riguardo
136 all'indicazione degli indirizzi remoti o locali attraverso i quali si vuole
137 effettuare la comunicazione.
138
139 \subsection{Il dominio, o \textit{protocol family}}
140 \label{sec:sock_domain}
141
142 Dati i tanti e diversi protocolli di comunicazione disponibili, esistono vari
143 tipi di socket, che vengono classificati raggruppandoli in quelli che si
144 chiamano \textsl{domini}.  La scelta di un dominio equivale in sostanza alla
145 scelta di una famiglia di protocolli. Ciascun dominio ha un suo nome simbolico
146 che convenzionalmente inizia con \texttt{PF\_} da \textit{protocol family},
147 altro nome con cui si indicano i domini.
148
149 A ciascun tipo di dominio corrisponde un analogo nome simbolico che inizia per
150 \texttt{AF\_} da \textit{address family}, e che identifica il formato degli
151 indirizzi usati in quel dominio; le man pages di Linux si riferiscono a questi
152 anche come \textit{name space}, (nome che però il manuale della glibc riserva
153 ai domini) e che identifica il formato degli indirizzi usati in quel dominio.
154
155 L'idea alla base della distinzione era che una famiglia di protocolli potesse
156 supportare vari tipi di indirizzi, per cui il prefisso \texttt{PF\_} si
157 sarebbe dovuto usare nella creazione dei socket e il prefisso \texttt{AF\_} in
158 quello delle strutture degli indirizzi; questo è quanto specificato anche
159 dallo standard POSIX.1g, ma non esistono a tuttora famiglie di protocolli che
160 supportino diverse strutture di indirizzi, per cui nella pratica questi due
161 nomi sono equivalenti e corrispondono agli stessi valori.
162
163 I domini (e i relativi nomi simbolici), così come i nomi delle famiglie di
164 indirizzi sono definiti dall'header \textit{socket.h}. In Linux le famiglie di
165 protocolli disponibili sono riportate in \ntab.
166
167 \begin{table}[htb]
168   \footnotesize
169   \centering
170   \begin{tabular}[c]{|l|l|l|}
171        \hline
172        \textbf{Nome}      & \textbf{Utilizzo}           &\textbf{Man page} \\
173        \hline
174        \hline
175        \macro{PF\_UNIX},
176        \macro{PF\_LOCAL}  & Local communication            & unix(7)    \\
177        \macro{PF\_INET}   & IPv4 Internet protocols        & ip(7)      \\
178        \macro{PF\_INET6}  & IPv6 Internet protocols        &            \\
179        \macro{PF\_IPX}    & IPX - Novell protocols         &            \\
180        \macro{PF\_NETLINK}& Kernel user interface device   & netlink(7) \\
181        \macro{PF\_X25}    & ITU-T X.25 / ISO-8208 protocol & x25(7)     \\
182        \macro{PF\_AX25}   & Amateur radio AX.25 protocol   &            \\
183        \macro{PF\_ATMPVC} & Access to raw ATM PVCs         &            \\
184        \macro{PF\_APPLETALK}& Appletalk                    & ddp(7)     \\
185        \macro{PF\_PACKET} & Low level packet interface     & packet(7)  \\    
186        \hline
187   \end{tabular}
188   \caption{Famiglie di protocolli definiti in Linux}
189   \label{tab:net_pf_names}
190 \end{table}
191
192 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
193 esempio in generale tutti i socket di tipo \macro{SOCK\_RAW} possono essere
194 creati solo da processi che hanno i privilegi di root (cioè effective uid
195 uguale a zero) o la capability \macro{CAP\_NET\_RAW}.
196
197
198 \subsection{Il tipo, o stile}
199 \label{sec:sock_type}
200
201 La scelta di un dominio non comporta però la scelta dello stile di
202 comunicazione, questo infatti viene a dipendere dal protocollo che si andrà ad
203 utilizzare fra quelli disponibili nella famiglia scelta. Le API permettono di
204 scegliere lo stile di comunicazione indicando il tipo di socket; Linux e le
205 glibc mettono a disposizione i seguenti tipi di socket (che il manuale della
206 glibc chiama \textit{styles}) definiti come \ctyp{int} in \file{socket.h}:
207
208 \begin{list}{}{}
209 \item \macro{SOCK\_STREAM} Provvede un canale di trasmissione dati
210   bidirezionale, sequenziale e affidabile. Opera su una connessione con un
211   altro socket. I dati vengono ricevuti e trasmessi come un flusso continuo di
212   byte (da cui il nome \textit{stream}). 
213 \item \macro{SOCK\_DGRAM} Viene usato per mandare pacchetti di lunghezza
214   massima fissata (\textit{datagram}) indirizzati singolarmente, senza
215   connessione e in maniera non affidabile. È l'opposto del precedente. 
216 \item \macro{SOCK\_SEQPACKET} Provvede un canale di trasmissione di dati
217   bidirezionale, sequenziale e affidabile. Opera su una connessione con un
218   altro socket. I dati possono solo essere trasmessi e letti per pacchetti (di
219   dimensione massima fissata).
220 \item \macro{SOCK\_RAW} Provvede l'accesso a basso livello ai protocolli di
221   rete e alle varie interfacce. I normali programmi di comunicazione non
222   devono usarlo.
223 \item \macro{SOCK\_RDM} Provvede un canale di trasmissione di pacchetti
224   affidabile ma in cui non è garantito l'ordine di arrivo dei pacchetti.
225 \item \macro{SOCK\_PACKET} Obsoleto, non deve essere usato.
226 \end{list}
227
228 Si tenga presente che non tutte le combinazioni di famiglia di protocolli e
229 tipo di socket sono valide, in quanto non è detto che nella famiglia esista un
230 protocollo per tutti gli stili di comunicazione indicati qui sopra. Una
231 tabella che mostra le combinazioni valide è la seguente:
232
233 \begin{table}[htb]
234   \footnotesize
235   \centering
236   \begin{tabular}{l|c|c|c|c|c|}
237    \multicolumn{1}{c}{} &\multicolumn{1}{c}{\macro{SOCK\_STREAM}}& 
238      \multicolumn{1}{c}{\macro{SOCK\_DGRAM}} & 
239      \multicolumn{1}{c}{\macro{SOCK\_RAW}} & 
240      \multicolumn{1}{c}{\macro{SOCK\_PACKET}}& 
241      \multicolumn{1}{c}{\macro{SOCK\_SEQPACKET}} \\
242      \cline{2-6}
243     \macro{PF\_UNIX}      &  si & si  &      &     &     \\
244      \cline{2-6}
245     \macro{PF\_INET}      & TCP & UDP & IPv4 &     &     \\
246      \cline{2-6}
247     \macro{PF\_INET6}     & TCP & UDP & IPv6 &     &     \\
248      \cline{2-6}
249     \macro{PF\_IPX}       &     &     &      &     &     \\
250      \cline{2-6}
251     \macro{PF\_NETLINK}   &     &  si &  si  &     &     \\
252      \cline{2-6}
253     \macro{PF\_X25}       &     &     &      &     &  si \\
254      \cline{2-6}
255     \macro{PF\_AX25}      &     &     &      &     &     \\
256      \cline{2-6}
257     \macro{PF\_ATMPVC}    &     &     &      &     &     \\
258      \cline{2-6}
259     \macro{PF\_APPLETALK} &     & si  &  si  &     &     \\
260      \cline{2-6}
261     \macro{PF\_PACKET}    &     & si  & si   &     &     \\    
262      \cline{2-6}
263   \end{tabular}
264   \caption{Combinazioni valide di dominio e tipo di protocollo per la 
265     funzione \func{socket}.}
266   \label{tab:sock_sock_valid_combinations}
267 \end{table}
268
269 Dove per ogni combinazione valida si è indicato il tipo di protocollo, o la
270 parola \textsl{si} qualora non il protocollo non abbia un nome definito,
271 mentre si sono lasciate vuote le caselle per le combinazioni non supportate.
272
273
274
275 \section{Le strutture degli indirizzi dei socket}
276 \label{sec:sock_sockaddr}
277
278 Come si è visto nella creazione di un socket non si specifica nulla oltre al
279 tipo di famiglia di protocolli che si vuole utilizzare, in particolare nessun
280 indirizzo che identifichi i due capi della comunicazione. La funzione infatti
281 si limita ad allocare nel kernel quanto necessario per poter poi realizzare la
282 comunicazione.
283
284 Gli indirizzi vengono specificati attraverso apposite strutture che vengono
285 utilizzate dalle altre funzioni della API dei socket quando la comunicazione
286 viene effettivamente realizzata. 
287
288 Ogni famiglia di protocolli ha ovviamente una sua forma di indirizzamento e in
289 corrispondenza a questa una sua peculiare struttura degli indirizzi; i nomi di
290 tutte queste strutture iniziano per \var{sockaddr\_}, quelli propri di
291 ciascuna famiglia vengono identificati dal suffisso finale, aggiunto al nome
292 precedente.
293
294
295 \subsection{La struttura generica}
296 \label{sec:sock_sa_gen}
297
298 Le strutture degli indirizzi vengono sempre passate alle varie funzioni
299 attraverso puntatori (cioè \textit{by reference}), ma le funzioni devono poter
300 maneggiare puntatori a strutture relative a tutti gli indirizzi possibili
301 nelle varie famiglie di protocolli; questo pone il problema di come passare
302 questi puntatori, il C ANSI risolve questo problema coi i puntatori generici
303 (i \ctyp{void *}), ma l'interfaccia dei socket è antecedente alla
304 definizione dello standard ANSI, e per questo nel 1982 fu scelto di definire
305 una struttura generica \type{sockaddr} per gli indirizzi dei socket mostrata
306 in \nfig:
307
308 \begin{figure}[!htb]
309   \footnotesize
310   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
311 struct sockaddr {
312     sa_family_t  sa_family;     /* address family: AF_xxx */
313     char         sa_data[14];   /* address (protocol-specific) */
314 };
315   \end{lstlisting}
316   \caption{La struttura generica degli indirizzi dei socket \type{sockaddr}}
317   \label{fig:sock_sa_gen_struct}
318 \end{figure}
319
320 Tutte le funzioni dei socket che usano gli indirizzi sono definite usando nel
321 prototipo un puntatore a questa struttura; per questo motivo quando si
322 invocano dette funzioni passando l'indirizzo di un protocollo specifico
323 occorrerà eseguire un casting del relativo puntatore.
324
325 I tipi di dati che compongono la struttura sono stabiliti dallo standard
326 POSIX.1g, riassunti in \ntab\ con i rispettivi file di include in cui sono
327 definiti; la struttura è invece definita nell'include file
328 \file{sys/socket.h}
329
330 \begin{table}[!htb]
331   \centering
332   \begin{tabular}{|l|l|l|}
333     \hline
334     \multicolumn{1}{|c|}{\textbf{Tipo}}& 
335     \multicolumn{1}{|c|}{\textbf{Descrizione}}& 
336     \multicolumn{1}{|c|}{\textbf{Header}} \\
337     \hline
338     \hline
339     \type{int8\_t}   & intero a 8 bit con segno   & \file{sys/types.h}\\
340     \type{uint8\_t}  & intero a 8 bit senza segno & \file{sys/types.h}\\
341     \type{int16\_t}  & intero a 16 bit con segno  & \file{sys/types.h}\\
342     \type{uint16\_t} & intero a 16 bit senza segno& \file{sys/types.h}\\
343     \type{int32\_t}  & intero a 32 bit con segno  & \file{sys/types.h}\\
344     \type{uint32\_t} & intero a 32 bit senza segno& \file{sys/types.h}\\
345     \hline
346     \type{sa\_family\_t} & famiglia degli indirizzi& \file{sys/socket.h}\\
347     \type{socklen\_t} & lunghezza (\type{uint32\_t}) dell'indirizzo di
348     un socket& \file{sys/socket.h}\\
349     \hline
350     \type{in\_addr\_t} & indirizzo IPv4 (\type{uint32\_t}) & 
351     \file{netinet/in.h}\\
352     \type{in\_port\_t} & porta TCP o UDP (\type{uint16\_t})& 
353     \file{netinet/in.h}\\
354     \hline
355   \end{tabular}
356   \caption{Tipi di dati usati nelle strutture degli indirizzi, secondo quanto 
357     stabilito dallo standard POSIX.1g}
358   \label{tab:sock_data_types}
359 \end{table}
360
361 In alcuni sistemi la struttura è leggermente diversa e prevede un primo membro
362 aggiuntivo \var{uint8\_t sin\_len} (come riportato da R. Stevens nei suoi
363 libri). Questo campo non verrebbe usato direttamente dal programmatore e non è
364 richiesto dallo standard POSIX.1g, in Linux pertanto non esiste. Il campo
365 \type{sa\_family\_t} era storicamente un \ctyp{unsigned short}.
366
367 Dal punto di vista del programmatore l'unico uso di questa struttura è quello
368 di fare da riferimento per il casting, per il kernel le cose sono un po'
369 diverse, in quanto esso usa il puntatore per recuperare il campo
370 \var{sa\_family} con cui determinare il tipo di indirizzo; per questo
371 motivo, anche se l'uso di un puntatore \ctyp{void *} sarebbe più immediato
372 per l'utente (che non dovrebbe più eseguire il casting), è stato mantenuto
373 l'uso di questa struttura.
374
375
376 \subsection{La struttura degli indirizzi IPv4}
377 \label{sec:sock_sa_ipv4}
378
379 I socket di tipo \macro{PF\_INET} vengono usati per la comunicazione
380 attraverso internet; la struttura per gli indirizzi per un socket internet
381 (IPv4) è definita come \type{sockaddr\_in} nell'header file
382 \file{netinet/in.h} e secondo le man page ha la forma mostrata in \nfig,
383 conforme allo standard POSIX.1g.
384
385 \begin{figure}[!htb]
386   \footnotesize
387   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
388 struct sockaddr_in {
389     sa_family_t     sin_family; /* address family: AF_INET */
390     u_int16_t       sin_port;   /* port in network byte order */
391     struct in_addr  sin_addr;   /* internet address */
392 };
393 /* Internet address. */
394 struct in_addr {
395     u_int32_t       s_addr;     /* address in network byte order */
396 };
397   \end{lstlisting}
398   \caption{La struttura degli indirizzi dei socket internet (IPv4)
399     \type{sockaddr\_in}.}
400   \label{fig:sock_sa_ipv4_struct}
401 \end{figure}
402
403 L'indirizzo di un socket internet (secondo IPv4) comprende l'indirizzo
404 internet di un'interfaccia più un numero di porta. Il protocollo IP non
405 prevede numeri di porta, che sono utilizzati solo dai protocolli di livello
406 superiore come TCP e UDP. Questa struttura però viene usata anche per i socket
407 RAW che accedono direttamente al livello di IP, nel qual caso il numero della
408 porta viene settato al numero di protocollo.
409
410 Il membro \var{sin\_family} deve essere sempre settato; \var{sin\_port}
411 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
412 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
413 servizi standard. Soltanto processi con i privilegi di root (effective uid
414 uguale a zero) o con la capability \macro{CAP\_NET\_BIND\_SERVICE} possono
415 usare la funzione \func{bind} su queste porte.
416
417 Il membro \var{sin\_addr} contiene l'indirizzo internet dell'altro capo
418 della comunicazione, e viene acceduto sia come struttura (un resto di una
419 implementazione precedente in cui questa era una \texttt{union} usata per
420 accedere alle diverse classi di indirizzi) che come intero.
421
422 Infine è da sottolineare che sia gli indirizzi che i numeri di porta devono
423 essere specificati in quello che viene chiamato \textit{network order}, cioè
424 con i bit ordinati in formato \textit{big endian}, questo comporta la
425 necessità di usare apposite funzioni di conversione per mantenere la
426 portabilità del codice (vedi \secref{sec:sock_addr_func} per i dettagli del
427 problema e le relative soluzioni).
428
429
430 \subsection{La struttura degli indirizzi IPv6}
431 \label{sec:sock_sa_ipv6}
432
433 Essendo IPv6 un'estensione di IPv4 i socket di tipo \macro{PF\_INET6} sono
434 sostanzialmente identici ai precedenti; la parte in cui si trovano
435 praticamente tutte le differenze è quella della struttura degli indirizzi. La
436 struttura degli indirizzi è definita ancora in \file{netinet/in.h}.
437
438 \begin{figure}[!htb]
439   \footnotesize
440   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
441 struct sockaddr_in6 {
442     u_int16_t       sin6_family;   /* AF_INET6 */
443     u_int16_t       sin6_port;     /* port number */
444     u_int32_t       sin6_flowinfo; /* IPv6 flow information */
445     struct in6_addr sin6_addr;     /* IPv6 address */
446     u_int32_t       sin6_scope_id; /* Scope id (new in 2.4) */
447 };
448
449 struct in6_addr {
450     unsigned char   s6_addr[16];   /* IPv6 address */
451 };
452   \end{lstlisting}
453   \caption{La struttura degli indirizzi dei socket IPv6 
454     \type{sockaddr\_in6}.}
455   \label{fig:sock_sa_ipv6_struct}
456 \end{figure}
457
458 Il campo \var{sin6\_family} deve essere sempre settato ad
459 \macro{AF\_INET6}, il campo \var{sin6\_port} è analogo a quello di IPv4 e
460 segue le stesse regole; il campo \var{sin6\_flowinfo} è a sua volta diviso
461 in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
462 successivi 4 bit la priorità e gli ultimi 4 sono riservati; questi valori
463 fanno riferimento ad alcuni campi specifici dell'header dei pacchetti IPv6
464 (vedi \secref{sec:IP_ipv6head}) ed il loro uso è sperimentale.
465
466 Il campo \var{sin6\_addr} contiene l'indirizzo a 128 bit usato da IPv6,
467 infine il campo \var{sin6\_scope\_id} è un campo introdotto con il kernel
468 2.4 per gestire alcune operazioni riguardanti il multicasting.
469  
470 Si noti che questa struttura è più grande di una \var{sockaddr} generica,
471 quindi occorre stare attenti a non avere fatto assunzioni riguardo alla
472 possibilità di contenere i dati nelle dimensioni di quest'ultima.
473
474
475 \subsection{La struttura degli indirizzi locali}
476 \label{sec:sock_sa_local}
477
478 I socket di tipo \macro{PF\_UNIX} vengono usati per una comunicazione
479 efficiente fra processi che stanno sulla stessa macchina; essi rispetto ai
480 precedenti possono essere anche creati in maniera anonima attraverso la
481 funzione \func{socketpair}. Quando però si vuole fare riferimento esplicito
482 ad uno di questi socket si deve usare la seguente struttura di indirizzi
483 definita nel file di header \file{sys/un.h}.
484
485 \begin{figure}[!htb]
486   \footnotesize
487   \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
488 #define UNIX_PATH_MAX    108
489 struct sockaddr_un {
490     sa_family_t  sun_family;              /* AF_UNIX */
491     char         sun_path[UNIX_PATH_MAX]; /* pathname */
492 };
493   \end{lstlisting}
494   \caption{La struttura degli indirizzi dei socket locali 
495     \var{sockaddr\_un}.}
496   \label{fig:sock_sa_local_struct}
497 \end{figure}
498
499 In questo caso il campo \var{sun\_family} deve essere \macro{AF\_UNIX},
500 mentre il campo \var{sun\_path} deve specificare un indirizzo; questo ha
501 due forme un file (di tipo socket) nel filesystem o una stringa univoca
502 (tenuta in uno spazio di nomi astratto). Nel primo caso l'indirizzo viene
503 specificato come una stringa (terminata da uno zero) corrispondente al
504 pathname del file; nel secondo invece \var{sun\_path} inizia con uno zero
505 vengono usati i restanti byte come stringa (senza terminazione).
506
507
508 % \subsection{Il passaggio delle strutture}
509 % \label{sec:sock_addr_pass}
510
511 % Come detto nelle funzioni della API dei socket le strutture degli indirizzi
512 % vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
513 % della struttura è passata come argomento, ma in questo caso la modalità del
514 % passaggio dipende dalla direzione del medesimo, dal processo al kernel o
515 % viceversa.
516
517 % In particolare le tre funzioni \texttt{bind}, \texttt{connect} e
518 % \texttt{sendto} passano la struttura al kernel, in questo caso è passata
519 % \textsl{per valore} anche la dimensione della medesima
520
521
522 % Le funzioni \texttt{accept}, \texttt{recvfrom}, \texttt{getsockname} e
523 % \texttt{getpeername} invece ricevono i valori del kernel 
524
525
526
527 \section{Le funzioni di conversione degli indirizzi}
528 \label{sec:sock_addr_func}
529
530 In questa sezione tratteremo delle varie funzioni usate per manipolare gli
531 indirizzi, limitandoci però agli indirizzi internet.
532
533 Come accennato gli indirizzi e i numeri di porta usati nella rete devono
534 essere forniti in formato opportuno (il \textit{network order}). Per capire
535 cosa significa tutto ciò occorre introdurre un concetto generale che tornerà
536 utile anche in seguito.
537
538
539 \subsection{La \textit{endianess}}
540 \label{sec:sock_endianess}
541
542 La rappresentazione di un numero binario in un computer può essere fatta in
543 due modi, chiamati rispettivamente \textit{big endian} e \textit{little
544   endian} a seconda di come i singoli bit vengono aggregati per formare le
545 variabili intere (in diretta corrispondenza a come sono poi in realtà cablati
546 sui bus interni del computer).
547
548 Per capire meglio il problema si consideri un intero a 16 bit scritto in una
549 locazione di memoria posta ad un certo indirizzo. I singoli bit possono essere
550 disposti un memoria in due modi, a partire dal più significativo o a partire
551 dal meno significativo. Così nel primo caso si troverà il byte che contiene i
552 bit più significativi all'indirizzo menzionato e il byte con i bit meno
553 significativi nell'indirizzo successivo; questo ordinamento è detto
554 \textit{little endian} dato che il dato finale è la parte ``piccola'' del
555 numero. Il caso opposto, in cui si parte dal bit meno significativo è detto
556 per lo stesso motivo \textit{big endian}.
557
558 La \textit{endianess} di un computer dipende essenzialmente dalla architettura
559 hardware usata; Intel e Digital usano il \textit{little endian}, Motorola,
560 IBM, Sun (sostanzialmente tutti gli altri) usano il \textit{big endian}. Il
561 formato della rete è anch'esso \textit{big endian}, altri esempi sono quello
562 del bus PC, che è \textit{little endian}, o quello del bus VME che è
563 \textit{big endian}.
564
565 Esistono poi anche dei processori che possono scegliere il tipo di formato
566 all'avvio e alcuni che, come il PowerPC o l'Intel i860, possono pure passare
567 da un tipo di ordinamento all'altro con una specifica istruzione. In ogni caso
568 in Linux l'ordinamento è definito dall'architettura e dopo l'avvio del sistema
569 resta sempre lo stesso, anche quando il processore permetterebbe di eseguire
570 questi cambiamenti.
571
572 \subsection{Le funzioni per il riordinamento}
573 \label{sec:sock_func_ord}
574
575 Il problema connesso all'endianess è che quando si passano dei dati da un tipo
576 di architettura all'altra i dati vengono interpretati in maniera diversa, e ad
577 esempio nel caso dell'intero a 16 bit ci si ritroverà con i due byte in cui è
578 suddiviso scambiati di posto, e ne sarà quindi invertito l'ordine di lettura
579 per cui, per riavere il valore originale dovranno essere rovesciati.
580
581 Per questo motivo si usano le seguenti funzioni di conversione che servono a
582 tener conto automaticamente della possibile differenza fra l'ordinamento usato
583 sul computer e quello che viene usato nelle trasmissione sulla rete; queste
584 funzioni sono:
585 \begin{prototype}{netinet/in.h}
586 {unsigned long int htonl(unsigned long int hostlong)} 
587   Converte l'intero a 32 bit \var{hostlong} dal formato della macchina a
588   quello della rete.
589 \end{prototype}
590 \begin{prototype}{netinet/in.h}
591 {unsigned short int htons(unsigned short int hostshort)}
592   Converte l'intero a 16 bit \var{hostshort} dal formato della macchina a
593   quello della rete.
594 \end{prototype}
595 \begin{prototype}{netinet/in.h}
596 {unsigned long int ntonl(unsigned long int netlong)}
597   Converte l'intero a 32 bit \var{netlong} dal formato della rete a quello
598   della macchina.
599 \end{prototype}
600 \begin{prototype}{netinet/in.h}
601 {unsigned sort int ntons(unsigned short int netshort)}
602   Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello
603   della macchina.
604 \end{prototype}
605 I nomi sono assegnati usando la lettera \texttt{n} come mnemonico per indicare
606 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera
607 \texttt{h} come mnemonico per l'ordinamento usato sulla macchina locale (da
608 \textit{host order}), mentre le lettere \texttt{s} e \texttt{l} stanno ad
609 indicare i tipi di dato (\ctyp{long} o \ctyp{short}, riportati anche dai
610 prototipi).
611
612 Usando queste funzioni si ha la conversione automatica: nel caso in cui la
613 macchina che si sta usando abbia una architettura \textit{big endian} queste
614 funzioni sono definite come macro che non fanno nulla. Per questo motivo vanno
615 sempre utilizzate, anche quando potrebbero non essere necessarie, in modo da
616 assicurare la portabilità del codice su tutte le architetture.
617
618
619 \subsection{Le funzioni \func{inet\_aton}, \func{inet\_addr} e 
620   \func{inet\_ntoa}}
621 \label{sec:sock_func_ipv4}
622
623 Un secondo insieme di funzioni di manipolazione serve per passare dal formato
624 binario usato nelle strutture degli indirizzi alla rappresentazione dei numeri
625 IP che si usa normalmente.
626
627 Le prime tre funzioni di manipolazione riguardano la conversione degli
628 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
629 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
630 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network
631   order}) e viceversa; in questo caso si usa la lettera \texttt{a} come
632 mnemonico per indicare la stringa. Dette funzioni sono:
633 \begin{prototype}{arpa/inet.h}
634   {int inet\_aton(const char *src, struct in\_addr *dest)} 
635   Converte la stringa puntata da \var{src} nell'indirizzo binario da
636   memorizzare all'indirizzo puntato da \var{dest}, restituendo 0 in caso di
637   successo e 1 in caso di fallimento (è espressa in questa forma in modo da
638   poterla usare direttamente con il puntatore usato per passare la struttura
639   degli indirizzi). Se usata con \var{dest} inizializzato a \macro{NULL}
640   effettua la validazione dell'indirizzo.
641 \end{prototype}
642 \begin{prototype}{arpa/inet.h}{in\_addr\_t inet\_addr(const char *strptr)}
643   Restituisce l'indirizzo a 32 bit in network order a partire dalla stringa
644   passata come parametro, in caso di errore restituisce il valore
645   \macro{INADDR\_NONE} che tipicamente sono trentadue bit a uno; questo
646   comporta che la stringa \texttt{255.255.255.255}, che pure è un indirizzo
647   valido, non può essere usata con questa funzione; per questo motivo essa è
648   generalmente deprecata in favore della precedente.
649 \end{prototype}  
650 \begin{prototype}{arpa/inet.h}{char *inet\_ntoa(struct in\_addr addrptr)}
651   Converte il valore a 32 bit dell'indirizzo (espresso in \textit{network
652     order}) restituendo il puntatore alla stringa che contiene l'espressione
653   in formato dotted decimal. Si deve tenere presente che la stringa risiede in
654   memoria statica, per cui questa funzione non è rientrante.
655 \end{prototype}
656
657
658 \subsection{Le funzioni \func{inet\_pton} e \func{inet\_ntop}}
659 \label{sec:sock_conv_func_gen}
660
661 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
662 motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e
663 \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in
664 questo caso le lettere \texttt{n} e \texttt{p} sono degli mnemonici per
665 ricordare il tipo di conversione effettuata e stanno per \textit{presentation}
666 e \textit{numeric}.
667
668 % \begin{figure}[htb]
669 %   \centering  
670
671 %   \caption{Schema della rappresentazioni utilizzate dalle funzioni di 
672 %     conversione \texttt{inet\_pton} e \texttt{inet\_ntop} }
673 %   \label{fig:sock_inet_conv_func}
674
675 % \end{figure}
676
677 Entrambe le funzioni accettano l'argomento \param{af} che indica il tipo di
678 indirizzo e può essere \macro{AF\_INET} o \macro{AF\_INET6}. Se la famiglia
679 indicata non è valida entrambe le funzioni settano la variabile \var{errno}
680 al valore \macro{EAFNOSUPPORT}. I prototipi delle suddette funzioni sono i
681 seguenti:
682 \begin{prototype}{sys/socket.h}
683   {int inet\_pton(int af, const char *src, void *addr\_ptr)} Converte la
684   stringa puntata da \var{src} nell'indirizzo IP da memorizzare
685   all'indirizzo puntato da \var{addr\_ptr}, la funzione restituisce un
686   valore positivo in caso di successo, e zero se la stringa non rappresenta un
687   indirizzo valido, e negativo se \var{af} specifica una famiglia di indirizzi
688   non valida.
689 \end{prototype}
690 \begin{prototype}{sys/socket.h}
691   {char *inet\_ntop(int af, const void *addr\_ptr, char *dest, size\_t len)}
692   Converte la struttura dell'indirizzo puntata da \var{addr\_ptr} in una
693   stringa che viene copiata nel buffer puntato dall'indirizzo \var{dest};
694   questo deve essere preallocato dall'utente e la lunghezza deve essere almeno
695   \macro{INET\_ADDRSTRLEN} in caso di indirizzi IPv4 e
696   \macro{INET6\_ADDRSTRLEN} per indirizzi IPv6; la lunghezza del buffer deve
697   comunque venire specificata attraverso il parametro \var{len}.
698  
699   \bodydesc{La funzione restituisce un puntatore non nullo a \var{dest} in
700     caso di successo e un puntatore nullo in caso di fallimento, in
701     quest'ultimo caso viene settata la variabile \var{errno} con il valore
702     \macro{ENOSPC} in caso le dimensioni dell'indirizzo eccedano la lunghezza
703     specificata da \var{len} o \macro{ENOAFSUPPORT} in caso \var{af} non sia
704     una famiglia di indirizzi valida.}
705 \end{prototype}
706
707 Gli indirizzi vengono convertiti da/alle rispettive strutture di indirizzo
708 (\var{struct  in\_addr} per IPv4, e \var{struct  in6\_addr} per IPv6), che
709 devono essere precedentemente allocate e passate attraverso il puntatore
710 \var{addr\_ptr}; il parametro \var{dest} di \func{inet\_ntop} non può essere
711 nullo e deve essere allocato precedentemente.
712
713 Il formato usato per gli indirizzi in formato di presentazione è la notazione
714 \textit{dotted decimal} per IPv4 e quella descritta in
715 \secref{sec:IP_ipv6_notation} per IPv6.
716
717
718
719 \section{Un esempio di applicazione}
720 \label{sec:sock_appplication}
721
722 Per evitare di rendere questa introduzione ai socket puramente teorica
723 iniziamo con il mostrare un esempio di un client TCP elementare.  Prima di
724 passare agli esempi del client e del server, esamineremo una caratteristica
725 delle funzioni di I/O sui socket che ci tornerà utile anche in seguito.
726
727
728 \subsection{Il comportamento delle funzioni di I/O}
729 \label{sec:sock_io_behav}
730
731 Una cosa di cui non sempre si è consapevoli quando si ha a che fare con i
732 socket è che le funzioni di input/output non sempre hanno lo stesso
733 comportamento che avrebbero con i normali files (in particolare questo accade
734 per i socket di tipo stream). 
735
736 Infatti con i socket è comune che funzioni come \func{read} o \func{write}
737 possano restituire in input o scrivere in output un numero di byte minore di
738 quello richiesto. Come già accennato in \secref{sec:file_read} questo è un
739 comportamento normale anche per l'I/O su file, e succede
740 perché si eccede in lettura o scrittura il limite di buffer del kernel.
741
742 In questo caso tutto quello che il programma chiamante deve fare è di ripetere
743 la lettura (o scrittura) per la quantità di byte rimanenti (lo stesso può
744 avvenire scrivendo più di 4096 byte in una pipe, dato che quello è il limite
745 di solito adottato per il buffer di trasmissione del kernel).
746
747 \begin{figure}[htb]
748   \centering
749   \footnotesize
750   \begin{lstlisting}{}
751 #include <unistd.h>
752
753 ssize_t SockRead(int fd, void *buf, size_t count) 
754 {
755     size_t nleft;
756     ssize_t nread;
757  
758     nleft = count;
759     while (nleft > 0) {             /* repeat until no left */
760         if ( (nread = read(fd, buf, nleft)) < 0) {
761             if (errno == EINTR) {   /* if interrupted by system call */
762                 continue;           /* repeat the loop */
763             } else {
764                 return(nread);      /* otherwise exit */
765             }
766         } else if (nread == 0) {    /* EOF */
767             break;                  /* break loop here */ 
768         }
769         nleft -= nread;             /* set left to read */
770         buf +=nread;                /* set pointer */
771     }
772     return (count - nleft);
773 }  
774   \end{lstlisting}
775   \caption{Funzione \func{SockRead}, legge \var{count} byte da un socket }
776   \label{fig:sock_SockRead_code}
777 \end{figure}
778
779 Per questo motivo seguendo l'esempio di W. R. Stevens si sono definite due
780 funzioni \func{SockRead} e \func{SockWrite} che eseguono la lettura da un
781 socket tenendo conto di questa caratteristica, ed in grado di ritornare dopo
782 avere letto o scritto esattamente il numero di byte specificato; il sorgente
783 è riportato in \curfig\ e \nfig\ ed è disponibile fra i sorgenti allegati alla
784 guida nei files \file{SockRead.c} e \file{SockWrite.c}.
785
786 \begin{figure}[htb]
787   \centering
788   \footnotesize
789   \begin{lstlisting}{}
790 #include <unistd.h>
791
792 ssize_t SockWrite(int fd, const void *buf, size_t count) 
793 {
794     size_t nleft;
795     ssize_t nwritten;
796
797     nleft = count;
798     while (nleft > 0) {             /* repeat until no left */
799         if ( (nwritten = write(fd, buf, nleft)) < 0) {
800             if (errno == EINTR) {   /* if interrupted by system call */
801                 continue;           /* repeat the loop */
802             } else {
803                 return(nwritten);   /* otherwise exit with error */
804             }
805         }
806         nleft -= nwritten;          /* set left to write */
807         buf +=nwritten;             /* set pointer */
808     }
809     return (count);
810 }  
811   \end{lstlisting}
812   \caption{Funzione \func{SockWrite}, scrive \var{count} byte su un socket }
813   \label{fig:sock_SockWrite_code}
814 \end{figure}
815
816 Come si può notare le funzioni ripetono la lettura/scrittura in un ciclo fino
817 all'esaurimento del numero di byte richiesti, in caso di errore viene
818 controllato se questo è \macro{EINTR} (cioè un'interruzione della system call
819 dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
820 l'errore viene ritornato interrompendo il ciclo.
821
822 Nel caso della lettura, se il numero di byte letti è zero, significa che si è
823 arrivati alla fine del file e pertanto si ritorna senza aver concluso la
824 lettura di tutti i byte richiesti.
825
826
827
828 \subsection{Un primo esempio di client}
829 \label{sec:net_cli_sample}
830
831 Lo scopo di questo esempio è fornire un primo approccio alla programmazione di
832 rete e vedere come si usano le funzioni descritte in precedenza, alcune delle
833 funzioni usate nell'esempio saranno trattate in dettaglio nel capitolo
834 successivo; qui ci limiteremo a introdurre la nomenclatura senza fornire
835 definizioni precise e dettagli di funzionamento che saranno trattati
836 estensivamente più avanti.
837
838 In \nfig\ è riportata la sezione principale del codice del nostro client
839 elementare per il servizio \textit{daytime}, un servizio standard che
840 restituisce l'ora locale della macchina a cui si effettua la richiesta.
841
842 \begin{figure}[!htb]
843   \footnotesize
844   \begin{lstlisting}{}
845 #include <sys/types.h>   /* predefined types */
846 #include <unistd.h>      /* include unix standard library */
847 #include <arpa/inet.h>   /* IP addresses conversion utilities */
848 #include <sys/socket.h>  /* socket library */
849 #include <stdio.h>       /* include standard I/O library */
850
851 int main(int argc, char *argv[])
852 {
853     int sock_fd;
854     int i, nread;
855     struct sockaddr_in serv_add;
856     char buffer[MAXLINE];
857      ...
858     /* create socket */
859     if ( (sock_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
860         perror("Socket creation error");
861         return -1;
862     }
863     /* initialize address */
864     memset((void *) &serv_add, 0, sizeof(serv_add)); /* clear server address */
865     serv_add.sin_family = AF_INET;                   /* address type is INET */
866     serv_add.sin_port = htons(13);                   /* daytime post is 13 */
867     /* build address using inet_pton */
868     if ( (inet_pton(AF_INET, argv[optind], &serv_add.sin_addr)) <= 0) {
869         perror("Address creation error");
870         return -1;
871     }
872     /* extablish connection */
873     if (connect(sock_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
874         perror("Connection error");
875         return -1;
876     }
877     /* read daytime from server */
878     while ( (nread = read(sock_fd, buffer, MAXLINE)) > 0) {
879         buffer[nread]=0;
880         if (fputs(buffer, stdout) == EOF) {          /* write daytime */
881             perror("fputs error");
882             return -1;
883         }
884     }
885     /* error on read */
886     if (nread < 0) {
887         perror("Read error");
888         return -1;
889     }
890     /* normal exit */
891     return 0;
892 }
893   \end{lstlisting}
894   \caption{Esempio di codice di un client elementare per il servizio daytime.}
895   \label{fig:net_cli_code}
896 \end{figure}
897
898 Il sorgente completo del programma (\file{ElemDaytimeTCPClient.c}, che
899 comprende il trattamento delle opzioni e una funzione per stampare un
900 messaggio di aiuto) è allegato alla guida nella sezione dei codici sorgente e
901 può essere compilato su una qualunque macchina Linux.
902
903 Il programma anzitutto include gli header necessari (\texttt{\small 1--5});
904 dopo la dichiarazione delle variabili (\texttt{\small 9--12}) si è omessa
905 tutta la parte relativa al trattamento degli argomenti passati dalla linea di
906 comando (effettuata con le apposite routine illustrate in
907 \capref{sec:proc_opt_handling}).
908
909 Il primo passo (\texttt{\small 14--18}) è creare un \textit{socket} IPv4
910 (\macro{AF\_INET}), di tipo TCP \macro{SOCK\_STREAM}. La funzione
911 \macro{socket} ritorna il descrittore che viene usato per identificare il
912 socket in tutte le chiamate successive. Nel caso la chiamata fallisca si
913 stampa un errore con la relativa routine e si esce.
914
915 Il passo seguente (\texttt{\small 19--27}) è quello di costruire un'apposita
916 struttura \type{sockaddr\_in} in cui sarà inserito l'indirizzo del server ed
917 il numero della porta del servizio. Il primo passo è inizializzare tutto a
918 zero, per poi inserire il tipo di protocollo e la porta (usando per
919 quest'ultima la funzione \func{htons} per convertire il formato dell'intero
920 usato dal computer a quello usato nella rete), infine si utilizza la funzione
921 \func{inet\_pton} per convertire l'indirizzo numerico passato dalla linea di
922 comando.
923
924 Usando la funzione \func{connect} sul socket creato in precedenza
925 (\texttt{\small 28--32}) si provvede poi a stabilire la connessione con il
926 server specificato dall'indirizzo immesso nella struttura passata come secondo
927 argomento, il terzo argomento è la dimensione di detta struttura. Dato che
928 esistono diversi tipi di socket, si è dovuto effettuare un cast della
929 struttura inizializzata in precedenza, che è specifica per i socket IPv4.  Un
930 valore di ritorno negativo implica il fallimento della connessione.
931
932 Completata con successo la connessione il passo successivo (\texttt{\small
933   34--40}) è leggere la data dal socket; il server invierà sempre una stringa
934 di 26 caratteri della forma \verb|Wed Apr 4 00:53:00 2001\r\n|, che viene
935 letta dalla funzione \func{read} e scritta su \file{stdout}.
936
937 Dato il funzionamento di TCP la risposta potrà tornare in un unico pacchetto
938 di 26 byte (come avverrà senz'altro nel caso in questione) ma potrebbe anche
939 arrivare in 26 pacchetti di un byte.  Per questo nel caso generale non si può
940 mai assumere che tutti i dati arrivino con una singola lettura, pertanto
941 quest'ultima deve essere effettuata in un ciclo in cui si continui a leggere
942 fintanto che la funzione \func{read} non ritorni uno zero (che significa che
943 l'altro capo ha chiuso la connessione) o un numero minore di zero (che
944 significa un errore nella connessione).
945
946 Si noti come in questo caso la fine dei dati sia specificata dal server che
947 chiude la connessione; questa è una delle tecniche possibili (è quella usata
948 pure dal protocollo HTTP), ma ce ne possono essere altre, ad esempio FTP marca
949 la conclusione di un blocco di dati con la sequenza ASCII \verb|\r\n|
950 (carriage return e line feed), mentre il DNS mette la lunghezza in testa ad
951 ogni blocco che trasmette. Il punto essenziale è che TCP non provvede nessuna
952 indicazione che permetta di marcare dei blocchi di dati, per cui se questo è
953 necessario deve provvedere il programma stesso.
954
955 \subsection{Un primo esempio di server}
956 \label{sec:net_serv_sample}
957
958 Dopo aver illustrato il client daremo anche un esempio di un server
959 elementare, in grado di rispondere al precedente client. Il listato è
960 nuovamente mostrato in \nfig, il sorgente completo
961 (\file{ElemDaytimeTCPServer.c}) è allegato insieme agli altri file nella
962 directory \file{sources}.
963
964 \begin{figure}[!htbp]
965   \footnotesize
966   \begin{lstlisting}{}
967 #include <sys/types.h>   /* predefined types */
968 #include <unistd.h>      /* include unix standard library */
969 #include <arpa/inet.h>   /* IP addresses conversion utilities */
970 #include <sys/socket.h>  /* socket library */
971 #include <stdio.h>       /* include standard I/O library */
972 #include <time.h>
973 #define MAXLINE 80
974 #define BACKLOG 10
975 int main(int argc, char *argv[])
976 {
977 /* 
978  * Variables definition  
979  */
980     int list_fd, conn_fd;
981     int i;
982     struct sockaddr_in serv_add;
983     char buffer[MAXLINE];
984     time_t timeval;
985     ...
986     /* create socket */
987     if ( (list_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
988         perror("Socket creation error");
989         exit(-1);
990     }
991     /* initialize address */
992     memset((void *)&serv_add, 0, sizeof(serv_add)); /* clear server address */
993     serv_add.sin_family = AF_INET;                  /* address type is INET */
994     serv_add.sin_port = htons(13);                  /* daytime port is 13 */
995     serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
996     /* bind socket */
997     if (bind(list_fd, (struct sockaddr *)&serv_add, sizeof(serv_add)) < 0) {
998         perror("bind error");
999         exit(-1);
1000     }
1001     /* listen on socket */
1002     if (listen(list_fd, BACKLOG) < 0 ) {
1003         perror("listen error");
1004         exit(-1);
1005     }
1006     /* write daytime to client */
1007     while (1) {
1008         if ( (conn_fd = accept(list_fd, (struct sockaddr *) NULL, NULL)) <0 ) {
1009             perror("accept error");
1010             exit(-1);
1011         }
1012         timeval = time(NULL);
1013         snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&timeval));
1014         if ( (write(conn_fd, buffer, strlen(buffer))) < 0 ) {
1015             perror("write error");
1016             exit(-1);
1017         }
1018         close(conn_fd);
1019     }
1020     /* normal exit */
1021     exit(0);
1022 }
1023   \end{lstlisting}
1024   \caption{Esempio di codice di un semplice server per il servizio daytime.}
1025   \label{fig:net_serv_code}
1026 \end{figure}
1027
1028 Come per il client si includono gli header necessari a cui è aggiunto quello
1029 per trattare i tempi, e si definiscono alcune costanti e le variabili
1030 necessarie in seguito (\texttt{\small 1--18}), come nel caso precedente si
1031 sono omesse le parti relative al trattamento delle opzioni da riga di comando.
1032
1033 La creazione del socket (\texttt{\small 22--26}) è analoga al caso precedente,
1034 come pure l'inizializzazione della struttura \type{sockaddr\_in}, anche in
1035 questo caso si usa la porta standard del servizio daytime, ma come indirizzo
1036 IP si il valore predefinito \macro{INET\_ANY} che corrisponde ad un indirizzo
1037 generico (\texttt{\small 27--31}).
1038
1039 Si effettua poi (\texttt{\small 32--36}) la chiamata alla funzione
1040 \func{bind} che permette di associare la precedente struttura al socket, in
1041 modo che quest'ultimo possa essere usato per accettare connessioni su una
1042 qualunque delle interfacce di rete locali.
1043
1044 Il passo successivo (\texttt{\small 37--41}) è mettere ``in ascolto'' il
1045 socket, questo viene effettuato con la funzione \func{listen} che dice al
1046 kernel di accettare connessioni per il socket specificato, la funzione indica
1047 inoltre, con il secondo parametro, il numero massimo di connessioni che il
1048 kernel accetterà di mettere in coda per il suddetto socket.
1049
1050 Questa ultima chiamata completa la preparazione del socket per l'ascolto (che
1051 viene chiamato anche \textit{listening descriptor}) a questo punto il processo
1052 è mandato in sleep (\texttt{\small 44--47}) con la successiva chiamata alla
1053 funzione \func{accept}, fin quando non arriva e viene accettata una
1054 connessione da un client.
1055
1056 Quando questo avviene \func{accept} ritorna un secondo descrittore di socket,
1057 che viene chiamato \textit{connected descriptor} che è quello che viene usato
1058 dalla successiva chiamata alla \func{write} per scrivere la risposta al
1059 client, una volta che si è opportunamente (\texttt{\small 48--49}) costruita
1060 la stringa con la data da trasmettere. Completata la trasmissione il nuovo
1061 socket viene chiuso (\texttt{\small 54}).  Il tutto è inserito in un ciclo
1062 infinito (\texttt{\small 42--55}) in modo da poter ripetere l'invio della data
1063 ad una successiva connessione.
1064
1065 È importante notare che questo server è estremamente elementare, infatti a
1066 parte il fatto di essere dipendente da IPv4, esso è in grado di servire solo
1067 un client alla volta, è cioè un \textsl{server iterativo}, inoltre esso è
1068 scritto per essere lanciato da linea di comando, se lo si volesse utilizzare
1069 come demone di sistema (che è in esecuzione anche quando non c'è nessuna shell
1070 attiva e il terminale da cui lo si è lanciato è stato sconnesso),
1071 occorrerebbero delle opportune modifiche.
1072
1073 %%% Local Variables: 
1074 %%% mode: latex
1075 %%% TeX-master: "gapil"
1076 %%% End: