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