socket.tex

   1 \chapter{Introduzione ai socket}
   2 \label{cha:socket_intro}
   3
   4 Il \textit{socket} (traducibile liberamente come \textsl{manicotto}) è uno dei
   5 principali meccanismi di comunicazione fra programmi utilizzato in ambito unix
   6 (e non solo). Il socket costituisce in sostanza un canale di comunicazione fra
   7 due processi su cui si possono leggere e scrivere dati analogo a quello di una
   8 pipe ma a differenza di questa e degli altri meccanismi esaminati nel capitolo
   9 \capref{cha:IPC} i socket non sono limitati alla comunicazione fra processi
  10 che girano sulla stessa macchina ma possono effettuare la comunicazione anche
  11 attraverso la rete.
  12
  13 Quella dei socket costituisce infatti la principale API (\textit{Application
  14   Program Interface}) usata nella programmazione di rete.  La loro origine
  15 risale al 1983, quando furono introdotti nel BSD 4.2; l'interfaccia è rimasta
  16 sostanzialmente la stessa con piccole modifiche negli anni successivi. Benché
  17 siano state sviluppate interfacce alternative, originate dai sistemi SYSV,
  18 come la XTI (\textit{X/Open Transport Interface}) nessuna ha mai raggiunto la
  19 diffusione e la popolarità di quella dei socket (né tantomeno usabilità e
  20 flessibilità).
  21
  22 La flessibilità e la genericità dell'interfaccia inoltre ha consentito di
  23 utilizzare i socket con i più disparati meccanismi di comunicazione, e non
  24 solo con la suite dei protocolli TCP/IP, che sarà comunque quella di cui
  25 tratteremo in maniera più estesa.
  26
  27
  28 \section{Concetti base}
  29 \label{sec:sock_gen}
  30
  31 Per capire il funzionamento dei socket occorre avere presente il funzionamento
  32 dei protocolli di rete (vedi \capref{cha:network}), ma l'interfaccia è del
  33 tutto generale e benché le problematiche (e quindi le modalità di risolvere i
  34 problemi) siano diverse a seconda del tipo di protocollo di comunicazione
  35 usato, le funzioni da usare restano le stesse.
  36
  37 Per questo motivo una semplice descrizione dell'interfaccia è assolutamente
  38 inutile, in quanto il comportamento di quest'ultima e le problematiche da
  39 affrontare cambiano radicalmente a seconda dello ``stile'' di comunicazione
  40 usato.  La scelta di questo stile va infatti ad incidere sulla semantica che
  41 verrà utilizzata a livello utente per gestire la comunicazione (su come
  42 inviare e ricevere i dati) e sul comportamento effettivo delle funzioni
  43 utilizzate.
  44
  45 La scelta di uno stile dipende sia dai meccanismi disponibili, sia dal tipo di
  46 comunicazione che si vuole effettuare. Ad esempio alcuni stili di
  47 comunicazione considerano i dati come una sequenza continua di bytes, altri
  48 invece li raggruppano in blocchi (i pacchetti).
  49
  50 Un'altro esempio di stile concerne la possibilità che la comunicazione possa o
  51 meno perdere dati, possa o meno non rispettare l'ordine in cui essi non sono
  52 inviati, o inviare dei pacchetti più volte (come nel caso di TCP e UDP).
  53
  54 Un terzo esempio di stile di comunicazione concerne le modalità in cui essa
  55 avviene, in certi casi essa può essere condotta con una connessione diretta
  56 con un solo partner come per una telefonata; altri casi possono prevedere una
  57 comunicazione come per lettera, in cui si scrive l'indirizzo su ogni
  58 pacchetto, altri ancora una comunicazione \textit{broadcast} come per la
  59 radio, in cui i pacchetti vengono emessi su appositi ``canali'' dove chiunque
  60 si collega possa riceverli.
  61
  62 É chiaro che ciascuno di questi stili comporta una modalità diversa di gestire
  63 la comunicazione, ad esempio se è inaffidabile occorrerà essere in grado di
  64 gestire la perdita o il rimescolamento dei dati.
  65
  66
  67 \section{La funzione \texttt{socket}}
  68 \label{sec:sock_socket}
  69
  70 La creazione di un socket avviene attraverso l'uso della funzione
  71 \texttt{socket} questa restituisce un \textit{socket descriptor} (un valore
  72 intero non negativo) che come gli analoghi file descriptor di files e alle
  73 pipes serve come riferimento al socket; in sostanza è l'indice nella tabella
  74 dei file che contiene i puntatori alle opportune strutture usate dal kernel ed
  75 allocate per ogni processo, (la stessa usata per i files e le pipes [NdA
  76 verificare!]).
  77
  78 Il prototipo della funzione è definito nell'header \texttt{sys/socket.h}, la
  79 funzione prende tre parametri, il dominio del socket (che definisce la
  80 famiglia di protocolli, vedi \secref{sec:sock_domain}), il tipo di socket (che
  81 definisce lo stile di comunicazione vedi \secref{sec:sock_type}) e il
  82 protocollo; in genere quest'ultimo è indicato implicitamente dal tipo di
  83 socket, per cui viene messo a zero (con l'eccezione dei \textit{raw socket}).
  84
  85 \begin{prototype}{int socket(int domain, int type, int protocol)}
  86
  87   La funzione restituisce un intero positivo se riesce, e -1 se fallisce, in
  88   quest'ultimo caso la variabile \texttt{errno} è settata con i seguenti
  89   codici di errore:
  90
  91   \begin{errlist}
  92   \item \texttt{EPROTONOSUPPORT} Il tipo di socket o il protocollo scelto non
  93     sono supportati nel dominio.
  94   \item \texttt{ENFILE} Il kernel non ha memoria sufficiente a creare una
  95     nuova struttura per il socket.
  96   \item \texttt{EMFILE} Si è ecceduta la tabella dei file.
  97   \item \texttt{EACCES} Non si hanno privilegi per creare un socket nel
  98     dominio o con il protocollo specificato.
  99   \item \texttt{EINVAL} Protocollo sconosciuto o dominio non disponibile.
 100   \item \texttt{ENOBUFS} o \texttt{ENOMEM} Non c'è sufficiente memoria per
 101     creare il socket.
 102   \end{errlist}
 103 \end{prototype}
 104
 105 Si noti che la creazione del socket non comporta nulla riguardo
 106 all'indicazione degli indirizzi remoti o locali attraverso i quali si vuole
 107 effettuare la comunicazione.
 108
 109 \subsection{Il dominio, o \textit{protocol family}}
 110 \label{sec:sock_domain}
 111
 112 Dati i tanti e diversi protocolli di comunicazione disponibili, esistono vari
 113 tipi di socket, che vengono classificati raggruppandoli in quelli che si
 114 chiamano \textsl{domini}.  La scelta di un dominio equivale in sostanza alla
 115 scelta di una famiglia di protocolli. Ciascun dominio ha un suo nome simbolico
 116 che convenzionalmente inizia con \texttt{PF\_} da \textit{protocol family},
 117 altro nome con cui si indicano i domini.
 118
 119 A ciascun tipo di dominio corrisponde un analogo nome simbolico che inizia per
 120 \texttt{AF\_} da \textit{address family}, e che identifica il formato degli
 121 indirizzi usati in quel dominio; le man pages di linux si riferiscono a questi
 122 anche come \textit{name space}, (nome che però il manuale della glibc riserva
 123 ai domini) e che identifica il formato degli indirizzi usati in quel dominio.
 124
 125 L'idea alla base della distinzione era che una famiglia di protocolli potesse
 126 supportare vari tipi di indirizzi, per cui il prefisso \texttt{PF\_} si
 127 sarebbe dovuto usare nella creazione dei socket e il prefisso \texttt{AF\_} in
 128 quello delle strutture degli indirizzi; questo è quanto specificato anche
 129 dallo standard POSIX.1g, ma non esistono a tuttora famiglie di protocolli che
 130 supportino diverse strutture di indirizzi, per cui nella pratica questi due
 131 nomi sono equivalenti e corrispondono agli stessi valori.
 132
 133 I domini (e i relativi nomi simbolici), così come i nomi delle famiglie di
 134 indirizzi sono definiti dall'header \textit{socket.h}. In linux le famiglie di
 135 protocolli disponibili sono riportate in \ntab.
 136
 137 \begin{table}[htb]
 138   \footnotesize
 139   \centering
 140   \begin{tabular}[c]{lll}
 141        Nome               & Utilizzo                       & Man page   \\
 142        \hline
 143        PF\_UNIX,PF\_LOCAL & Local communication            & unix(7)    \\
 144        PF\_INET           & IPv4 Internet protocols        & ip(7)      \\
 145        PF\_INET6          & IPv6 Internet protocols        &            \\
 146        PF\_IPX            & IPX - Novell protocols         &            \\
 147        PF\_NETLINK        & Kernel user interface device   & netlink(7) \\
 148        PF\_X25            & ITU-T X.25 / ISO-8208 protocol & x25(7)     \\
 149        PF\_AX25           & Amateur radio AX.25 protocol   &            \\
 150        PF\_ATMPVC         & Access to raw ATM PVCs         &            \\
 151        PF\_APPLETALK      & Appletalk                      & ddp(7)     \\
 152        PF\_PACKET         & Low level packet interface     & packet(7)  \\
 153   \end{tabular}
 154   \caption{Famiglie di protocolli definiti in linux}
 155   \label{tab:net_pf_names}
 156 \end{table}
 157
 158 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
 159 esempio in generale tutti i socket di tipo \texttt{SOCK\_RAW} possono essere
 160 creati solo da processi che hanno i provilegi di root (cioè effective uid
 161 uguale a zero) o la capability \texttt{CAP\_NET\_RAW}.
 162
 163
 164 \subsection{Il tipo, o stile}
 165 \label{sec:sock_type}
 166
 167 La scelta di un dominio non comporta però la scelta dello stile di
 168 comunicazione, questo infatti viene a dipendere dal protocollo che si andrà ad
 169 utilizzare fra quelli disponibili nella famiglia scelta. Le API permettono di
 170 scegliere lo stile di comunicazione indicando il tipo di socket; linux e le
 171 glibc mettono a disposizione i seguenti tipi di socket (che il manuale della
 172 glibc chiama \textit{styles}) definiti come \texttt{int} in \texttt{socket.h}:
 173
 174 \begin{list}{}{}
 175 \item \texttt{SOCK\_STREAM} Provvede un canale di trasmissione dati
 176   bidirezionale, sequenziale e affidabile. Opera su una connessione con un
 177   altro socket. I dati vengono ricevuti e trasmessi come un flusso continuo di
 178   byte (da cui il nome \textit{stream}).
 179 \item \texttt{SOCK\_DGRAM} Viene usato per mandare pacchetti di lunghezza
 180   massima fissata (\textit{datagram}) indirizzati singolarmente, senza
 181   connessione e in maniera non affidabile. È l'opposto del precedente.
 182 \item \texttt{SOCK\_SEQPACKET} Provvede un canale di trasmissione di dati
 183   bidirezionale, sequenziale e affidabile. Opera su una connessione con un
 184   altro socket. I dati possono solo essere trasmessi e letti per pacchetti (di
 185   dimensione massima fissata).
 186 \item \texttt{SOCK\_RAW} Provvede l'accesso a basso livello ai protocolli di
 187   rete e alle varie interfacce. I normali programmi di comunicazione non
 188   devono usarlo.
 189 \item \texttt{SOCK\_RDM} Provvede un canale di trasmissione di pacchetti
 190   affidabile ma in cui non è garantito l'ordine di arrivo dei pacchetti.
 191 \item \texttt{SOCK\_PACKET} Obsoleto, non deve essere usato.
 192 \end{list}
 193
 194 Si tenga presente che non tutte le combinazioni di famiglia di protocolli e
 195 tipo di socket sono valide, in quanto non è detto che nella famiglia esista un
 196 protocollo per tutti gli stili di comunicazione indicati qui sopra. Una
 197 tabella che mostra le combinazioni valide è la seguente:
 198
 199 \begin{table}[htb]
 200   \footnotesize
 201   \centering
 202   \begin{tabular}{l|c|c|c|c|c|}
 203    \multicolumn{1}{c}{} &\multicolumn{1}{c}{\texttt{SOCK\_STREAM}}&
 204      \multicolumn{1}{c}{\texttt{SOCK\_DGRAM}} &
 205      \multicolumn{1}{c}{\texttt{SOCK\_RAW}} &
 206      \multicolumn{1}{c}{\texttt{SOCK\_PACKET}}&
 207      \multicolumn{1}{c}{\texttt{SOCK\_SEQPACKET}} \\
 208      \cline{2-6}
 209     \texttt{PF\_UNIX}      &  si & si  &      &     &     \\
 210      \cline{2-6}
 211     \texttt{PF\_INET}      & TCP & UDP & IPv4 &     &     \\
 212      \cline{2-6}
 213     \texttt{PF\_INET6}     & TCP & UDP & IPv6 &     &     \\
 214      \cline{2-6}
 215     \texttt{PF\_IPX}       &     &     &      &     &     \\
 216      \cline{2-6}
 217     \texttt{PF\_NETLINK}   &     &  si &  si  &     &     \\
 218      \cline{2-6}
 219     \texttt{PF\_X25}       &     &     &      &     &  si \\
 220      \cline{2-6}
 221     \texttt{PF\_AX25}      &     &     &      &     &     \\
 222      \cline{2-6}
 223     \texttt{PF\_ATMPVC}    &     &     &      &     &     \\
 224      \cline{2-6}
 225     \texttt{PF\_APPLETALK} &     & si  &  si  &     &     \\
 226      \cline{2-6}
 227     \texttt{PF\_PACKET}    &     & si  & si   &     &     \\
 228      \cline{2-6}
 229   \end{tabular}
 230   \caption{Combinazioni valide di dominio e tipo di protocollo per la funzione \texttt{socket}.}
 231   \label{tab:sock_sock_valid_combinations}
 232 \end{table}
 233
 234 Dove per ogni combinazione valida si è indicato il tipo di protocollo, o la
 235 parola \textsl{si} qualora non il protocollo non abbia un nome definito,
 236 mentre si sono lasciate vuote le caselle per le combinazioni non supportate.
 237
 238 \section{Le strutture degli indirizzi dei socket}
 239 \label{sec:sock_sockaddr}
 240
 241 Come si è visto nella creazione di un socket non si specifica nulla oltre al
 242 tipo di famiglia di protocolli che si vuole utilizzare, in particolare nessun
 243 indirizzo che identifichi i due capi della comunicazione. La funzione infatti
 244 si limita ad allocare nel kernel quanto necessario per poter poi realizzare la
 245 comunicazione.
 246
 247 Gli indirizzi vengono specificati attraverso apposite strutture che vengono
 248 utilizzate dalle altre funzioni della API dei socket quando la comunicazione
 249 viene effettivamente realizzata.
 250
 251 Ogni famiglia di protocolli ha ovviamente una sua forma di indirizzamento e in
 252 corrispondenza a questa una sua peculiare struttura degli indirizzi; i nomi di
 253 tutte queste strutture iniziano per \texttt{sockaddr\_}, quelli propri di
 254 ciascuna famiglia vengono identificati dal suffisso finale, aggiunto al nome
 255 precedente.
 256
 257 \subsection{La struttura generica}
 258 \label{sec:sock_sa_gen}
 259
 260 Le strutture degli indirizzi vengono sempre passate alle varie funzioni
 261 attraverso puntatori (cioè \textit{by reference}), ma le funzioni devono poter
 262 maneggiare puntatori a strutture relative a tutti gli indirizzi possibili
 263 nelle varie famiglie di protocolli; questo pone il problema di come passare
 264 questi puntatori, il C ANSI risolve questo problema coi i puntatori generici
 265 (i \texttt{void *}), ma l'interfaccia dei socket è antecendente alla
 266 definizione dello standard ANSI, e per questo nel 1982 fu scelto di definire
 267 una struttura generica \texttt{sockaddr} per gli indirizzi dei socket mostrata
 268 in \nfig:
 269
 270 \begin{figure}[!htbp]
 271   \footnotesize
 272   \begin{lstlisting}{}
 273 struct sockaddr {
 274     sa_family_t  sa_family;     /* address family: AF_xxx */
 275     char         sa_data[14];   /* address (protocol-specific) */
 276 };
 277   \end{lstlisting}
 278   \caption{La struttura generica degli indirizzi dei socket \texttt{sockaddr}}
 279   \label{fig:sock_sa_gen_struct}
 280 \end{figure}
 281
 282 Tutte le funzioni dei socket che usano gli indirizzi sono definite usando nel
 283 prototipo un puntatore a questa struttura; per questo motivo quando si
 284 invocano dette funzioni passando l'indirizzo di un protocollo specifico
 285 occorrerà eseguire un casting del relativo puntatore.
 286
 287 I tipi di dati che compongono la struttura sono stabiliti dallo standard
 288 Posix.1g, riassunti in \ntab\ con i rispettivi file di include in cui sono
 289 definiti; la struttura è invece definita nell'include file
 290 \texttt{sys/socket.h}
 291
 292 \begin{table}[!htbp]
 293   \centering
 294   \begin{tabular}{|l|l|l|}
 295     \hline
 296     \multicolumn{1}{|c|}{Tipo}& \multicolumn{1}{|c|}{Descrizione}&
 297     \multicolumn{1}{|c|}{Header} \\
 298     \hline
 299     \hline
 300     \texttt{int8\_t}   & intero a 8 bit con segno   & \texttt{sys/types.h}\\
 301     \texttt{uint8\_t}  & intero a 8 bit senza segno & \texttt{sys/types.h}\\
 302     \texttt{int16\_t}  & intero a 16 bit con segno  & \texttt{sys/types.h}\\
 303     \texttt{uint16\_t} & intero a 16 bit senza segno& \texttt{sys/types.h}\\
 304     \texttt{int32\_t}  & intero a 32 bit con segno  & \texttt{sys/types.h}\\
 305     \texttt{uint32\_t} & intero a 32 bit senza segno& \texttt{sys/types.h}\\
 306     \hline
 307     \texttt{sa\_family\_t} & famiglia degli indirizzi& \texttt{sys/socket.h}\\
 308     \texttt{socklen\_t} & lunghezza (\texttt{uint32\_t}) dell'indirizzo di
 309     un socket& \texttt{sys/socket.h}\\
 310     \hline
 311     \texttt{in\_addr\_t} & indirizzo IPv4 (\texttt{uint32\_t}) &
 312     \texttt{netinet/in.h}\\
 313     \texttt{in\_port\_t} & porta TCP o UDP (\texttt{uint16\_t})&
 314     \texttt{netinet/in.h}\\
 315     \hline
 316   \end{tabular}
 317   \caption{Tipi di dati usati nelle strutture degli indirizzi, secondo quanto
 318     stabilito dallo standard Posix.1g}
 319   \label{tab:sock_data_types}
 320 \end{table}
 321
 322 In alcuni sistemi la struttura è leggermente diversa e prevede un primo membro
 323 aggiuntivo \texttt{uint8\_t sin\_len} (come riportato da R. Stevens nei suoi
 324 libri). Questo campo non verrebbe usato direttamente dal programmatore e non è
 325 richiesto dallo standard Posix.1g, in linux pertanto non sussiste. Il campo
 326 \texttt{sa\_family\_t} era storicamente un \texttt{unsigned short}.
 327
 328 Dal punto di vista del programmatore l'unico uso di questa struttura è quello
 329 di fare da riferimento per il casting, per il kernel le cose sono un po'
 330 diverse, in quanto esso usa il puntatore per recuperare il campo
 331 \texttt{sa\_family} con cui determinare il tipo di indirizzo; per questo
 332 motivo, anche se l'uso di un puntatore \texttt{void *} sarebbe più immediato
 333 per l'utente (che non dovrebbe più eseguire il casting), è stato mantenuto
 334 l'uso di questa struttura.
 335
 336
 337 \subsection{La struttura degli indirizzi IPv4}
 338 \label{sec:sock_sa_ipv4}
 339
 340 I socket di tipo \texttt{PF\_INET} vengono usati per la comunicazione
 341 attraverso internet; la struttura per gli indirizzi per un socket internet
 342 (IPv4) è definita come \texttt{sockaddr\_in} nell'header file
 343 \texttt{netinet/in.h} e secondo le man page ha la forma mostrata in \nfig,
 344 conforme allo standard Posix.1g.
 345
 346
 347 \begin{figure}[!htbp]
 348   \footnotesize
 349   \begin{lstlisting}{}
 350 struct sockaddr_in {
 351     sa_family_t     sin_family; /* address family: AF_INET */
 352     u_int16_t       sin_port;   /* port in network byte order */
 353     struct in_addr  sin_addr;   /* internet address */
 354 };
 355 /* Internet address. */
 356 struct in_addr {
 357     u_int32_t       s_addr;     /* address in network byte order */
 358 };
 359   \end{lstlisting}
 360   \caption{La struttura degli indirizzi dei socket internet (IPv4)
 361     \texttt{sockaddr\_in}.}
 362   \label{fig:sock_sa_ipv4_struct}
 363 \end{figure}
 364
 365 L'indirizzo di un socket internet (secondo IPv4) comprende l'indirizzo
 366 internet di un'interfaccia più un numero di porta. Il protocollo IP non
 367 prevede numeri di porta, che sono utilizzati solo dai protocolli di livello
 368 superiore come TCP e UDP. Questa struttura però viene usata anche per i socket
 369 RAW che accedono direttamente al livello di IP, nel qual caso il numero della
 370 porta viene settato al numero di protocollo.
 371
 372 Il membro \texttt{sin\_family} deve essere sempre settato; \texttt{sin\_port}
 373 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
 374 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
 375 servizi standard. Soltanto processi con i privilegi di root (effective uid
 376 uguale a zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE} possono
 377 usare la funzione \texttt{bind} su queste porte.
 378
 379 Il membro \texttt{sin\_addr} contiene l'indirizzo internet dell'altro capo
 380 della comunicazione, e viene acceduto sia come struttura (un resto di una
 381 implementazione precedente in cui questa era una union usata per accedere alle
 382 diverse classi di indirizzi) che come intero.
 383
 384 Infine è da sottolineare che sia gli indirizzi che i numeri di porta devono
 385 essere specificati in quello che viene chiamato \textit{network order}, cioè
 386 con i bit ordinati in formato \textit{big endian}, questo comporta la
 387 necessità di usare apposite funzioni di conversione per mantenere la
 388 portabilità del codice (vedi \secref{sec:sock_addr_func} per i dettagli del
 389 problema e le relative soluzioni).
 390
 391 \subsection{La struttura degli indirizzi IPv6}
 392 \label{sec:sock_sa_ipv6}
 393
 394 Essendo IPv6 una estenzione di IPv4 i socket di tipo \texttt{PF\_INET6} sono
 395 sostanzialmente identici ai precedenti; la parte in cui si trovano
 396 praticamente tutte le differenze è quella della struttura degli indirizzi. La
 397 struttura degli indirizzi è definita ancora in \texttt{netinet/in.h}.
 398
 399 \begin{figure}[!htbp]
 400   \footnotesize
 401   \begin{lstlisting}{}
 402 struct sockaddr_in6 {
 403     u_int16_t       sin6_family;   /* AF_INET6 */
 404     u_int16_t       sin6_port;     /* port number */
 405     u_int32_t       sin6_flowinfo; /* IPv6 flow information */
 406     struct in6_addr sin6_addr;     /* IPv6 address */
 407     u_int32_t       sin6_scope_id; /* Scope id (new in 2.4) */
 408 };
 409
 410 struct in6_addr {
 411     unsigned char   s6_addr[16];   /* IPv6 address */
 412 };
 413   \end{lstlisting}
 414   \caption{La struttura degli indirizzi dei socket IPv6
 415     \texttt{sockaddr\_in6}.}
 416   \label{fig:sock_sa_ipv6_struct}
 417 \end{figure}
 418
 419 Il campo \texttt{sin6\_family} deve essere sempre settato ad
 420 \texttt{AF\_INET6}, il campo \texttt{sin6\_port} è analogo a quello di IPv4 e
 421 segue le stesse regole; il campo \texttt{sin6\_flowinfo} è a dua volta diviso
 422 in tre parti di cui i 24 bit inferiori indicano l'etichetta di flusso, i
 423 successivi 4 bit la priorità e gli ultimi 4 sono riservati; questi valori
 424 fanno riferimento ad alcuni campi specifici dell'header dei pacchetti IPv6
 425 (vedi \secref{sec:appA_ipv6}) ed il loro uso è sperimentale.
 426
 427 Il campo \texttt{sin6\_addr} contiene l'indirizzo a 128 bit usato da IPv6,
 428 infine il campo \texttt{sin6\_scope\_id} è un campo introdotto con il kernel
 429 2.4 per gestire alcune operazioni riguardanti il multicasting.
 430
 431 Si noti che questa struttura è più grande di una \texttt{sockaddr} generica,
 432 quindi occorre stare attenti a non avere fatto assunzioni riguardo alla
 433 possibilità di contenere i dati nelle dimensioni di quest'ultima.
 434
 435
 436 \subsection{La struttura degli indirizzi locali}
 437 \label{sec:sock_sa_local}
 438
 439 I socket di tipo \texttt{PF\_UNIX} vengono usati per una comunicazione
 440 efficiente fra processi che stanno sulla stessa macchina; essi rispetto ai
 441 precedenti possono essere anche creati in maniera anonima attraverso la
 442 funzione \texttt{socketpair}. Quando però si vuole fare riferimento esplicito
 443 ad uno di questi socket si deve usare la seguente struttura di indirizzi
 444 definita nel file di header \texttt{sys/un.h}.
 445
 446 \begin{figure}[!htbp]
 447   \footnotesize
 448   \begin{lstlisting}{}
 449 #define UNIX_PATH_MAX    108
 450 struct sockaddr_un {
 451     sa_family_t  sun_family;              /* AF_UNIX */
 452     char         sun_path[UNIX_PATH_MAX]; /* pathname */
 453 };
 454   \end{lstlisting}
 455   \caption{La struttura degli indirizzi dei socket locali
 456     \texttt{sockaddr\_un}.}
 457   \label{fig:sock_sa_local_struct}
 458 \end{figure}
 459
 460 In questo caso il campo \texttt{sun\_family} deve essere \texttt{AF\_UNIX},
 461 mentre il campo \texttt{sun\_path} deve specificare un indirizzo; questo ha
 462 due forme un file (di tipo socket) nel filesystem o una stringa univoca
 463 (tenuta in uno spazio di nomi astratto). Nel primo caso l'indirizzo viene
 464 specificato come una stringa (terminata da uno zero) corrispondente al
 465 pathname del file; nel secondo invece \texttt{sun\_path} inizia con uno zero
 466 vengono usati i restanti bytes come stringa (senza terminazione).
 467
 468
 469 % \subsection{Il passaggio delle strutture}
 470 % \label{sec:sock_addr_pass}
 471
 472 % Come detto nelle funzioni della API dei socket le strutture degli indirizzi
 473 % vengono sempre passate per riferimento usando un puntatore; anche la lunghezza
 474 % della struttura è passata come argomento, ma in questo caso la modalità del
 475 % passaggio dipende dalla direzione del medesimo, dal processo al kernel o
 476 % viceversa.
 477
 478 % In particolare le tre funzioni \texttt{bind}, \texttt{connect} e
 479 % \texttt{sendto} passano la struttura al kernel, in questo caso è passata
 480 % \textsl{per valore} anche la dimensione della medesima
 481
 482
 483 % Le funzioni \texttt{accept}, \texttt{recvfrom}, \texttt{getsockname} e
 484 % \texttt{getpeername} invece ricevono i valori del kernel
 485
 486
 487 \section{Le funzioni di conversione degli indirizzi}
 488 \label{sec:sock_addr_func}
 489
 490 In questa sezione tratteremo delle varie funzioni usate per manipolare gli
 491 indirizzi, limitandoci però agli indirizzi internet.
 492
 493 Come accennato gli indirizzi e i numeri di porta usati nella rete devono
 494 essere forniti in formato opportuno (il \textit{network order}). Per capire
 495 cosa significa tutto ciò occorre introdurre un concetto generale che tornerà
 496 utile anche in seguito.
 497
 498
 499 \subsection{La \textit{endianess}}
 500 \label{sec:sock_endianess}
 501
 502 La rappresentazione di un numbero binario in un computer può essere fatta in
 503 due modi, chiamati rispettivamente \textit{big endian} e \textit{little
 504   endian} a seconda di come i singoli bit vengono aggregati per formare le
 505 variabili intere (in diretta corrispondenza a come sono poi in realtà cablati
 506 sui bus interni del computer).
 507
 508 Per capire meglio il problema si consideri un intero a 16 bit scritto in una
 509 locazione di memoria posta ad un certo indirizzo. I singoli bit possono essere
 510 disposti un memoria in due modi, a partire dal più significativo o a partire
 511 dal meno significativo. Così nel primo caso si troverà il byte che contiene i
 512 bit più significativi all'indirizzo menzionato e il byte con i bit meno
 513 significativi nell'indirizzo successivo; questo ordinamento è detto
 514 \textit{little endian} dato che il dato finale è la parte ``piccola'' del
 515 numero. Il caso opposto, in cui si parte dal bit meno significativo è detto
 516 per lo stesso motivo \textit{big endian}.
 517
 518 La \textit{endianess} di un computer dipende essenzialmente dalla architettura
 519 hardware usata; intel e digital usano il little endian, motorola, ibm, sun
 520 (sostanzialmente tutti gli altri) usano il big endian. Il formato della rete è
 521 anch'esso big endian. Esistono poi anche dei processori che possono scegliere
 522 il tipo di formato all'avvio e alcuni, come il PowerPC o l'intel i860, possono
 523 pure passare da un tipo all'altro con una specifica istruzione; in ogni caso
 524 in linux l'ordinamanento è definito dall'archiettura e anche se questi
 525 cambiamenti sono possibili anche dopo che il sistema è avviato, non vengono
 526 mai eseguiti.
 527
 528 \subsection{Le funzioni per il riordinamento}
 529 \label{sec:sock_func_ord}
 530
 531 Il problema connesso all'endianess è che quando si passano dei dati da un tipo
 532 di architettura all'altra i dati vengono interpretati in maniera diversa, e ad
 533 esempio nel caso dell'intero a 16 bit ci si ritroverà con i due bytes in cui è
 534 suddiviso scambiati di posto, e ne sarà quindi invertito l'ordine di lettura
 535 per cui, per riavere il valore originale dovrenno essere rovesciati.
 536
 537 Per questo motivo si usano le seguenti funzioni di conversione (i cui
 538 prototipi sono definiti in \texttt{netinet/in.h}) che servono a tener conto
 539 automaticamente della possibile differenza fra l'ordinamento usato sul
 540 computer e quello che viene usato nelle trasmissione sulla rete; queste
 541 funzioni sono:{
 542 \begin{prototype}{unsigned long int htonl(unsigned long int hostlong)}
 543   Converte l'intero a 32 bit \texttt{hostlong} dal formato della macchina a
 544   quello della rete.
 545 \end{prototype}
 546 \begin{prototype}{unsigned sort int htons(unsigned short int hostshort)}
 547   Converte l'intero a 16 bit \texttt{hostshort} dal formato della macchina a
 548   quello della rete.
 549 \end{prototype}
 550 \begin{prototype}{unsigned long int ntonl(unsigned long int netlong)}
 551   Converte l'intero a 32 bit \texttt{netlong} dal formato della rete a quello
 552   della macchina.
 553 \end{prototype}
 554 \begin{prototype}{unsigned sort int ntons(unsigned short int netshort)}
 555   Converte l'intero a 16 bit \texttt{netshort} dal formato della rete a quello
 556   della macchina.
 557 \end{prototype}
 558 I nomi sono assegnati usando la lettera $n$ come mnemonico per indicare
 559 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera $h$
 560 come mnemonico per l'ordinamento usato sulla macchina locale (da \textit{host
 561   order}), mentre le lettere $s$ e $l$ stanno ad indicare i tipi di dato
 562 (\texttt{long} o \texttt{short}, riportati anche dai prototipi).
 563
 564 Usando queste funzioni si ha la conversione automatica (nel caso pure la
 565 macchina sia in big endian queste funzioni sono definite come macro che non
 566 fanno nulla); esse vanno sempre utilizzate per assicurare la portabilità del
 567 codice su tutte le architetture.
 568
 569
 570 \subsection{Le funzioni \texttt{inet\_aton}, \texttt{inet\_addr} e
 571   \texttt{inet\_ntoa}}
 572 \label{sec:sock_func_ipv4}
 573
 574 Un secondo insieme di funzioni di manipolazione (i cui prototipi sono definiti
 575 in \texttt{arpa/inet.h}) serve per passare dal formato binario usato nelle
 576 strutture degli indirizzi alla rappresentazione dei numeri IP che si usa
 577 normalente.
 578
 579 Le prime tre funzioni di manipolazione riguardano la conversione degli
 580 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
 581 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
 582 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network
 583   order}) e viceversa; in questo caso si usa la lettera $a$ come mnemonico per
 584 indicare la stringa. Dette funzioni sono:
 585 \begin{prototype}{int inet\_aton(const char *src, struct in\_addr *dest)}
 586   Converte la stringa puntata da \texttt{src} nell'indirizzo binario da
 587   memorizzare all'indirizzo puntato da \texttt{dest}, restituendo 0 in caso
 588   di successo e 1 in caso di fallimento (è espressa in questa forma in modo da
 589   poterla usare direttamente con il puntatore usato per passare la struttura
 590   degli indirizzi). Se usata con \texttt{dest} inizializzato a
 591   \texttt{NULL} effettua la validazione dell'indirizzo.
 592 \end{prototype}
 593 \begin{prototype}{in\_addr\_t inet\_addr(const char *strptr)}
 594   Restituisce l'indirizzo a 32 bit in network order a partire dalla stringa
 595   passata come parametro, in caso di errore restituisce il valore
 596   \texttt{INADDR\_NONE} che tipicamente sono trentadue bit a uno; questo
 597   comporta che la stringa \texttt{255.255.255.255}, che pure è un indirizzo
 598   valido, non può essere usata con questa funzione; per questo motivo essa è
 599   generalmente deprecata in favore della precedente.
 600 \end{prototype}
 601 \begin{prototype}{char *inet\_ntoa(struct in\_addr addrptr)}
 602   Converte il valore a 32 bit dell'indirizzo (espresso in network order)
 603   restituendo il puntatore alla stringa che contiene l'espressione in formato
 604   dotted decimal. Si deve tenere presente che la stringa risiede in memoria
 605   statica, per cui questa funzione non è rientrante.
 606 \end{prototype}
 607
 608
 609 \subsection{Le funzioni \texttt{inet\_pton} e \texttt{inet\_ntop}}
 610 \label{sec:sock_conv_func_gen}
 611
 612 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
 613 motivo è preferibile usare le due nuove funzioni \texttt{inet\_pton} e
 614 \texttt{inet\_ntop} che possono convertire anche gli indirizzi IPv6 (secondo
 615 lo schema in \nfig). Anche in questo caso le lettere $n$ e $p$ sono degli
 616 mnemonici per ricordare il tipo di conversione effettuata e stanno per
 617 \textit{presentation} e \textit{numeric}.
 618
 619 \begin{figure}[htb]
 620   \centering
 621
 622   \caption{Schema della rappresentazioni utilizzate dalle funzioni di
 623     conversione \texttt{inet\_pton} e \texttt{inet\_ntop} }
 624   \label{fig:sock_inet_conv_func}
 625
 626 \end{figure}
 627
 628 Entrambe le funzioni accettano l'argomento \texttt{family} che indica il tipo
 629 di indirizzo e può essere \texttt{AF\_INET} o \texttt{AF\_INET6}. Se la
 630 famiglia indicata non è valida entrambe le funzioni ritornano un valore
 631 negativo e settano la variabile \texttt{errno} al valore
 632 \texttt{EAFNOSUPPORT}. I prototipi delle suddette funzioni sono i seguenti:
 633 \begin{prototype}{int inet\_pton(int family, const char *src, void *dest)}
 634   Converte la stringa puntata da \texttt{src} nell'indirizzo binario da
 635   memorizzare all'indirizzo puntato da \texttt{dest}, restituendo 0 in caso di
 636   successo e 1 in caso di fallimento.
 637 \end{prototype}
 638 \begin{prototype}{char *inet\_ntop(int family, const void *src, char *dest,
 639     size\_t len)}
 640   Converte la struttura dell'indirizzo puntata da \texttt{src} in una stringa
 641   che viene copiata nel buffer puntato dall'indirizzo \texttt{dest}; questo
 642   deve essere preallocato dall'utente e la lunghezza deve essere almeno
 643   \texttt{INET\_ADDRSTRLEN} in caso di indirizzi IPv4 e
 644   \texttt{INET6\_ADDRSTRLEN} per indirizzi IPv6; la lunghezza del buffer deve
 645   comunque venire specificata attraverso il parametro \texttt{len}.
 646
 647   La funzione restituisce un puntatore non nullo a \texttt{dest} in caso di
 648   successo e un puntatore nullo in caso di fallimento, in quest'ultimo caso
 649   viene settata la variabile \texttt{errno} con il valore \texttt{ENOSPC} in
 650   caso le dimensioni dell'indirizzo eccedano la lunghezza specificata da
 651   \texttt{len}.
 652 \end{prototype}
 653
 654
 655 \section{Il comportamento delle funzioni di I/O}
 656 \label{sec:sock_io_behav}
 657
 658 Una cosa di cui non sempre si è consapevoli quando si ha a che fare con i
 659 socket è che le funzioni di input/output non sempre hanno lo stesso
 660 comportamento che avrebbero con i normali files (in particolare questo accade
 661 per i socket di tipo stream).
 662
 663 Infatti con i socket può accadere che funzioni come \texttt{read} o
 664 \texttt{write} possano restituire in input o scrivere in output un numero di
 665 bytes minore di quello richiesto. Questo è un comportamento normale e non un
 666 errore, e succede perché si eccede in lettura o scrittura il limite di buffer
 667 del kernel.
 668
 669 In questo caso tutto quello che il programma chiamante deve fare è di ripetere
 670 la lettura (o scrittura) per la quantità di bytes rimanenti (lo stesso può
 671 avvenire scrivendo più di 4096 bytes in una pipe, dato che quello è il limite
 672 di solito adottato per il buffer di trasmissione del kernel).
 673
 674 \begin{figure}[htb]
 675   \centering
 676   \footnotesize
 677   \begin{lstlisting}{}
 678 #include <unistd.h>
 679
 680 ssize_t SockRead(int fd, void *buf, size_t count)
 681 {
 682     size_t nleft;
 683     ssize_t nread;
 684
 685     nleft = count;
 686     while (nleft > 0) {             /* repeat until no left */
 687         if ( (nread = read(fd, buf, nleft)) < 0) {
 688             if (errno == EINTR) {   /* if interrupted by system call */
 689                 continue;           /* repeat the loop */
 690             } else {
 691                 return(nread);      /* otherwise exit */
 692             }
 693         } else if (nread == 0) {    /* EOF */
 694             break;                  /* break loop here */
 695         }
 696         nleft -= nread;             /* set left to read */
 697         buf +=nread;                /* set pointer */
 698     }
 699     return (count - nleft);
 700 }
 701   \end{lstlisting}
 702   \caption{Funzione \texttt{SockRead}, legge $n$ bytes da un socket }
 703   \label{fig:sock_SockRead_code}
 704 \end{figure}
 705
 706 Per questo motivo seguendo l'esempio di W. R. Stevens si sono definite due
 707 funzioni \texttt{SockRead} e \texttt{SockWrite} che eseguono la lettura da un
 708 socket tenendo conto di questa caratteristica, ed in grado di ritornare dopo
 709 avere letto o scritto esattamente il numero di bytes specificato; il sorgente
 710 è riportato in \curfig\ e \nfig\ ed è disponibile fra i sorgenti allegati alla
 711 guida nei files \texttt{SockRead.c} e \texttt{SockWrite.c}.
 712
 713 \begin{figure}[htb]
 714   \centering
 715   \footnotesize
 716   \begin{lstlisting}{}
 717 #include <unistd.h>
 718
 719 ssize_t SockWrite(int fd, const void *buf, size_t count)
 720 {
 721     size_t nleft;
 722     ssize_t nwritten;
 723
 724     nleft = count;
 725     while (nleft > 0) {             /* repeat until no left */
 726         if ( (nwritten = write(fd, buf, nleft)) < 0) {
 727             if (errno == EINTR) {   /* if interrupted by system call */
 728                 continue;           /* repeat the loop */
 729             } else {
 730                 return(nwritten);   /* otherwise exit with error */
 731             }
 732         }
 733         nleft -= nwritten;          /* set left to write */
 734         buf +=nwritten;             /* set pointer */
 735     }
 736     return (count);
 737 }
 738   \end{lstlisting}
 739   \caption{Funzione \texttt{SockWrite}, scrive $n$ bytes su un socket }
 740   \label{fig:sock_SockWrite_code}
 741 \end{figure}
 742
 743 Come si può notare le funzioni ripetono la lettura/scrittura in un loop fino
 744 all'esaurimento del numero di bytes richiesti, in caso di errore viene
 745 controllato se questo è \texttt{EINTR} (cioè un'interruzione della system call
 746 dovuta ad un segnale), nel qual caso l'accesso viene ripetuto, altrimenti
 747 l'errore viene ritornato interrompendo il loop.
 748
 749 Nel caso della lettura se il numero di bytes letti è zero significa che è
 750 arrivati alla fine del file e pertanto si ritorna senza aver concluso la
 751 lettura di tutti i bytes richiesti.
 752