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