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