socket.tex

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