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