socket.tex

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