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