socket.tex

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