+
+Una volta che un file è stato aperto su possono leggere i dati che contiene
+utilizzando la funzione \func{read}, il cui prototipo è:
+\begin{prototype}{unistd.h}{ssize\_t read(int fd, void * buf, size\_t count)}
+
+ Cerca di leggere \var{count} byte dal file \var{fd} al buffer \var{buf}.
+
+ \bodydesc{La funzione ritorna il numero di byte letti in caso di successo e
+ -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+ valori:
+ \begin{errlist}
+ \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
+ aver potuto leggere qualsiasi dato.
+ \item[\macro{EAGAIN}] la funzione non aveva nessun dato da restituire e si
+ era aperto il file in modalità \macro{O\_NONBLOCK}.
+ \end{errlist}
+ ed inoltre \macro{EBADF}, \macro{EIO}, \macro{EISDIR}, \macro{EBADF},
+ \macro{EINVAL} e \macro{EFAULT} ed eventuali altri errori dipendenti dalla
+ natura dell'oggetto connesso a \var{fd}.}
+\end{prototype}
+
+La funzione tenta di leggere \var{count} byte a partire dalla posizione
+corrente nel file. Dopo la lettura la posizione sul file è spostata
+automaticamente in avanti del numero di byte letti. Se \var{count} è zero la
+funzione restituisce zero senza nessun altro risultato.
+
+Si deve sempre tener presente che non è detto che la funzione \func{read}
+restituisca sempre il numero di byte richiesto, ci sono infatti varie ragioni
+per cui la funzione può restituire un numero di byte inferiore; questo è un
+comportamento normale, e non un errore, che bisogna sempre tenere presente.
+
+La prima e più ovvia di queste ragioni è che si è chiesto di leggere più byte
+di quanto il file ne contenga. In questo caso il file viene letto fino alla
+sua fine, e la funzione ritorna regolarmente il numero di byte letti
+effettivamente.
+
+Raggiunta la fine del file, alla ripetizione di un'operazione di lettura,
+otterremmo il ritorno immediato di \func{read} con uno zero. La condizione
+raggiungimento della fine del file non è un errore, e viene segnalata appunto
+da un valore di ritorno di \func{read} nullo. Ripetere ulteriormente la
+lettura non avrebbe nessun effetto se non quello di continuare a ricevere zero
+come valore di ritorno.
+
+Con i \textsl{file regolari} questa è l'unica situazione in cui si può avere
+un numero di byte letti inferiore a quello richiesto, ma questo non è vero
+quando si legge da un terminale, da una fifo o da una pipe. In tal caso
+infatti, se non ci sono dati in ingresso, la \func{read} si blocca (a meno di
+non aver selezionato la modalità non bloccante, vedi
+\secref{sec:file_noblocking}) e ritorna solo quando ne arrivano; se il numero
+di byte richiesti eccede quelli disponibili la funzione ritorna comunque, ma
+con un numero di byte inferiore a quelli richiesti.
+
+Lo stesso comportamento avviene caso di lettura dalla rete (cioè su un socket,
+come vedremo in \secref{sec:sock_io_behav}), o per la lettura da certi file di
+dispositivo, come le unità a nastro, che restituiscono sempre i dati ad un
+singolo blocco alla volta.
+
+In realtà anche le due condizioni segnalate dagli errori \macro{EINTR} e
+\macro{EAGAIN} non sono errori. La prima si verifica quando la \func{read} è
+bloccata in attesa di dati in ingresso e viene interrotta da un segnale; in
+tal caso l'azione da prendere è quella di rieseguire la funzione. Torneremo in
+dettaglio sull'argomento in \secref{sec:sig_gen_beha}.
+
+La seconda si verifica quando il file è in modalità non bloccante (vedi
+\secref{sec:file_noblocking}) e non ci sono dati in ingresso: la funzione
+allora ritorna immediatamente con un errore \macro{EAGAIN}\footnote{sotto BSD
+ questo per questo errore viene usata la costante \macro{EWOULDBLOCK}, in
+ Linux, con le glibc, questa è sinonima di \macro{EAGAIN}.} che nel caso
+indica soltanto che occorrerà provare a ripetere la lettura.
+
+La funzione \func{read} è una delle system call fondamentali, esistenti fin
+dagli albori di Unix, ma nella seconda versione delle \textit{Single Unix
+ Specification}\footnote{questa funzione, e l'analoga \func{pwrite} sono
+ state aggiunte nel kernel 2.1.60, il supporto nelle \acr{glibc}, compresa
+ l'emulazione per i vecchi kernel che non hanno la system call, è stato
+ aggiunto con la versione 2.1, in versioni precedenti sia del kernel che
+ delle librerie la funzione non è disponibile.} (quello che viene chiamato
+normalmente Unix98, vedi \secref{sec:intro_opengroup}) è stata introdotta la
+definizione di un'altra funzione di lettura, \func{pread}, il cui prototipo è:
+\begin{prototype}{unistd.h}
+{ssize\_t pread(int fd, void * buf, size\_t count, off\_t offset)}
+
+Cerca di leggere \var{count} byte dal file \var{fd}, a partire dalla posizione
+\var{offset}, nel buffer \var{buf}.
+
+\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e -1
+ in caso di errore, nel qual caso \var{errno} viene settata secondo i valori
+ già visti per \func{read} e \func{lseek}.}
+\end{prototype}
+\noindent che però diventa accessibile solo con la definizione della macro:
+\begin{verbatim}
+ #define _XOPEN_SOURCE 500
+\end{verbatim}
+
+Questa funzione serve quando si vogliono leggere dati dal file senza
+modificarne la posizione corrente. È equivalente alla esecuzione di una
+\func{read} seguita da una \func{lseek} che riporti al valore precedente la
+posizione corrente sul file, ma permette di eseguire l'operazione
+atomicamente. Questo può essere importante quando la posizione sul file viene
+condivisa da processi diversi (vedi \secref{sec:file_sharing}). Il valore di
+\var{offset} fa sempre riferimento all'inizio del file.
+
+