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