+\label{sec:file_line_io}
+
+La terza ed ultima modalità di input/output non formattato è quella di linea,
+in cui si legge o si scrive una riga alla volta; questa è una modalità molto
+usata per l'I/O da terminale, ma è anche quella che presenta le
+caratteristiche più controverse.
+
+Le funzioni previste dallo standard ANSI C per leggere una linea sono
+sostanzialmente due, \funcd{gets} e \funcd{fgets}, i cui rispettivi
+prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{char *gets(char *string)} Scrive su \param{string} una
+ linea letta da \var{stdin}.
+
+ \funcdecl{char *fgets(char *string, int size, FILE *stream)}
+ Scrive su \param{string} la linea letta da \param{stream} per un
+ massimo di \param{size} byte.
+
+ \bodydesc{Le funzioni restituiscono l'indirizzo \param{string} in caso
+ di successo o \val{NULL} in caso di errore.}
+\end{functions}
+
+Entrambe le funzioni effettuano la lettura (dal file specificato \func{fgets},
+dallo standard input \func{gets}) di una linea di caratteri (terminata dal
+carattere \textit{newline}, \verb|'\n'|, quello mappato sul tasto di ritorno a
+capo della tastiera), ma \func{gets} sostituisce \verb|'\n'| con uno zero,
+mentre \func{fgets} aggiunge uno zero dopo il \textit{newline}, che resta
+dentro la stringa. Se la lettura incontra la fine del file (o c'è un errore)
+viene restituito un \val{NULL}, ed il buffer \param{buf} non viene toccato.
+L'uso di \func{gets} è deprecato e deve essere assolutamente evitato; la
+funzione infatti non controlla il numero di byte letti, per cui nel caso la
+stringa letta superi le dimensioni del buffer, si avrà un
+\itindex{buffer~overflow} \textit{buffer overflow}, con sovrascrittura della
+memoria del processo adiacente al buffer.\footnote{questa tecnica è spiegata
+ in dettaglio e con molta efficacia nell'ormai famoso articolo di Aleph1
+ \cite{StS}.}
+
+Questa è una delle vulnerabilità più sfruttate per guadagnare accessi non
+autorizzati al sistema (i cosiddetti \textit{exploit}), basta infatti inviare
+una stringa sufficientemente lunga ed opportunamente forgiata per
+sovrascrivere gli indirizzi di ritorno nello \itindex{stack} \textit{stack}
+(supposto che la \func{gets} sia stata chiamata da una subroutine), in modo da
+far ripartire l'esecuzione nel codice inviato nella stringa stessa (in genere
+uno \textit{shell code} cioè una sezione di programma che lancia una shell).
+
+La funzione \func{fgets} non ha i precedenti problemi di \func{gets} in quanto
+prende in input la dimensione del buffer \param{size}, che non verrà mai
+ecceduta in lettura. La funzione legge fino ad un massimo di \param{size}
+caratteri (newline compreso), ed aggiunge uno zero di terminazione; questo
+comporta che la stringa possa essere al massimo di \code{size-1} caratteri. Se
+la linea eccede la dimensione del buffer verranno letti solo \code{size-1}
+caratteri, ma la stringa sarà sempre terminata correttamente con uno zero
+finale; sarà possibile leggere i rimanenti caratteri in una chiamata
+successiva.
+
+Per la scrittura di una linea lo standard ANSI C prevede altre due
+funzioni, \funcd{fputs} e \funcd{puts}, analoghe a quelle di lettura, i
+rispettivi prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int puts(const char *string)} Scrive su \var{stdout} la
+ linea \param{string}.
+
+ \funcdecl{int fputs(const char *string, FILE *stream)} Scrive su
+ \param{stream} la linea \param{string}.
+
+ \bodydesc{Le funzioni restituiscono un valore non negativo in caso di
+ successo o \val{EOF} in caso di errore.}
+\end{functions}
+
+Dato che in questo caso si scrivono i dati in uscita \func{puts} non ha i
+problemi di \func{gets} ed è in genere la forma più immediata per scrivere
+messaggi sullo standard output; la funzione prende una stringa terminata da
+uno zero ed aggiunge automaticamente il ritorno a capo. La differenza con
+\func{fputs} (a parte la possibilità di specificare un file diverso da
+\var{stdout}) è che quest'ultima non aggiunge il newline, che deve essere
+previsto esplicitamente.
+
+Come per le analoghe funzioni di input/output a caratteri, anche per l'I/O di
+linea esistono delle estensioni per leggere e scrivere linee di caratteri
+estesi, le funzioni in questione sono \funcd{fgetws} e \funcd{fputws} ed i
+loro prototipi sono:
+\begin{functions}
+ \headdecl{wchar.h}
+ \funcdecl{wchar\_t *fgetws(wchar\_t *ws, int n, FILE *stream)}
+ Legge un massimo di \param{n} caratteri estesi dal file
+ \param{stream} al buffer \param{ws}.
+
+ \funcdecl{int fputws(const wchar\_t *ws, FILE *stream)} Scrive la
+ linea \param{ws} di caratteri estesi sul file \param{stream}.
+
+ \bodydesc{Le funzioni ritornano rispettivamente \param{ws} o un numero
+ non negativo in caso di successo e \val{NULL} o \val{EOF} in
+ caso di errore o fine del file.}
+\end{functions}
+
+Il comportamento di queste due funzioni è identico a quello di \func{fgets} e
+\func{fputs}, a parte il fatto che tutto (numero di caratteri massimo,
+terminatore della stringa, newline) è espresso in termini di caratteri estesi
+anziché di normali caratteri ASCII.
+
+Come per l'I/O binario e quello a caratteri, anche per l'I/O di linea le
+\acr{glibc} supportano una serie di altre funzioni, estensioni di tutte quelle
+illustrate finora (eccetto \func{gets} e \func{puts}), che eseguono
+esattamente le stesse operazioni delle loro equivalenti, evitando però il lock
+implicito dello stream (vedi sez.~\ref{sec:file_stream_thread}). Come per le
+altre forma di I/O, dette funzioni hanno lo stesso nome della loro analoga
+normale, con l'aggiunta dell'estensione \code{\_unlocked}.
+
+Come abbiamo visto, le funzioni di lettura per l'input/output di linea
+previste dallo standard ANSI C presentano svariati inconvenienti. Benché
+\func{fgets} non abbia i gravissimi problemi di \func{gets}, può
+comunque dare risultati ambigui se l'input contiene degli zeri; questi
+infatti saranno scritti sul buffer di uscita e la stringa in output
+apparirà come più corta dei byte effettivamente letti. Questa è una
+condizione che è sempre possibile controllare (deve essere presente un
+newline prima della effettiva conclusione della stringa presente nel
+buffer), ma a costo di una complicazione ulteriore della logica del
+programma. Lo stesso dicasi quando si deve gestire il caso di stringa
+che eccede le dimensioni del buffer.
+
+Per questo motivo le \acr{glibc} prevedono, come estensione GNU, due nuove
+funzioni per la gestione dell'input/output di linea, il cui uso permette di
+risolvere questi problemi. L'uso di queste funzioni deve essere attivato
+definendo la macro \macro{\_GNU\_SOURCE} prima di includere \file{stdio.h}. La
+prima delle due, \funcd{getline}, serve per leggere una linea terminata da un
+newline, esattamente allo stesso modo di \func{fgets}, il suo prototipo è:
+\begin{prototype}{stdio.h}
+ {ssize\_t getline(char **buffer, size\_t *n, FILE *stream)} Legge una linea
+ dal file \param{stream} copiandola sul buffer indicato da \param{buffer}
+ riallocandolo se necessario (l'indirizzo del buffer e la sua dimensione
+ vengono sempre riscritte).
+
+ \bodydesc{La funzione ritorna il numero di caratteri letti in caso di
+ successo e -1 in caso di errore o di raggiungimento della fine del
+ file.}
+\end{prototype}
+
+La funzione permette di eseguire una lettura senza doversi preoccupare della
+eventuale lunghezza eccessiva della stringa da leggere. Essa prende come primo
+argomento l'indirizzo del puntatore al buffer su cui si vuole copiare la
+linea. Quest'ultimo \emph{deve} essere stato allocato in precedenza con una
+\func{malloc} (non si può passare l'indirizzo di un puntatore ad una variabile
+locale); come secondo argomento la funzione vuole l'indirizzo della variabile
+contenente le dimensioni del buffer suddetto.
+
+Se il buffer di destinazione è sufficientemente ampio la stringa viene scritta
+subito, altrimenti il buffer viene allargato usando \func{realloc} e la nuova
+dimensione ed il nuovo puntatore vengono restituiti indietro (si noti infatti
+come per entrambi gli argomenti si siano usati dei
+\itindex{value~result~argument} \textit{value result argument}, passando dei
+puntatori anziché i valori delle variabili, secondo la tecnica spiegata in
+sez.~\ref{sec:proc_var_passing}).
+
+Se si passa alla funzione l'indirizzo di un puntatore impostato a \val{NULL} e
+\var{*n} è zero, la funzione provvede da sola all'allocazione della memoria
+necessaria a contenere la linea. In tutti i casi si ottiene dalla funzione un
+puntatore all'inizio del testo della linea letta. Un esempio di codice può
+essere il seguente:
+\includecodesnip{listati/getline.c}
+e per evitare \itindex{memory~leak} \textit{memory leak} occorre ricordarsi di
+liberare \var{ptr} con una \func{free}.
+
+Il valore di ritorno della funzione indica il numero di caratteri letti
+dallo stream (quindi compreso il newline, ma non lo zero di
+terminazione); questo permette anche di distinguere eventuali zeri letti
+dallo stream da quello inserito dalla funzione per terminare la linea.
+Se si è alla fine del file e non si è potuto leggere nulla o c'è stato
+un errore la funzione restituisce -1.
+
+La seconda estensione GNU è una generalizzazione di \func{getline} per
+poter usare come separatore un carattere qualsiasi, la funzione si
+chiama \funcd{getdelim} ed il suo prototipo è:
+\begin{prototype}{stdio.h}
+{ssize\_t getdelim(char **buffer, size\_t *n, int delim, FILE *stream)}
+ Identica a \func{getline} solo che usa \param{delim} al posto del
+ carattere di newline come separatore di linea.
+\end{prototype}
+
+Il comportamento di \func{getdelim} è identico a quello di \func{getline} (che
+può essere implementata da questa passando \verb|'\n'| come valore di
+\param{delim}).
+
+
+\subsection{L'input/output formattato}
+\label{sec:file_formatted_io}
+
+L'ultima modalità di input/output è quella formattata, che è una delle
+caratteristiche più utilizzate delle librerie standard del C; in genere questa
+è la modalità in cui si esegue normalmente l'output su terminale poiché
+permette di stampare in maniera facile e veloce dati, tabelle e messaggi.
+
+L'output formattato viene eseguito con una delle 13 funzioni della famiglia
+\func{printf}; le tre più usate sono \funcd{printf}, \funcd{fprintf} e
+\funcd{sprintf}, i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+ \funcdecl{int printf(const char *format, ...)} Stampa su \file{stdout}
+ gli argomenti, secondo il formato specificato da \param{format}.
+
+ \funcdecl{int fprintf(FILE *stream, const char *format, ...)} Stampa
+ su \param{stream} gli argomenti, secondo il formato specificato da
+ \param{format}.
+
+ \funcdecl{int sprintf(char *str, const char *format, ...)} Stampa
+ sulla stringa \param{str} gli argomenti, secondo il formato
+ specificato da \param{format}.
+
+ \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
+\end{functions}
+\noindent le prime due servono per stampare su file (lo standard output o
+quello specificato) la terza permette di stampare su una stringa, in genere
+l'uso di \func{sprintf} è sconsigliato in quanto è possibile, se non si ha la
+sicurezza assoluta sulle dimensioni del risultato della stampa, eccedere le
+dimensioni di \param{str}, con conseguente sovrascrittura di altre variabili e
+possibili \itindex{buffer~overflow} \textit{buffer overflow}; per questo
+motivo si consiglia l'uso dell'alternativa \funcd{snprintf}, il cui prototipo
+è:
+\begin{prototype}{stdio.h}
+{snprintf(char *str, size\_t size, const char *format, ...)}
+ Identica a \func{sprintf}, ma non scrive su \param{str} più di
+ \param{size} caratteri.
+\end{prototype}
+
+La parte più complessa delle funzioni di scrittura formattata è il formato
+della stringa \param{format} che indica le conversioni da fare, e da cui
+deriva anche il numero degli argomenti che dovranno essere passati a seguire
+(si noti come tutte queste funzioni siano \index{variadic} \textit{variadic},
+prendendo un numero di argomenti variabile che dipende appunto da quello che
+si è specificato in \param{format}).
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Tipo} & \textbf{Significato} \\
+ \hline
+ \hline
+ \cmd{\%d} &\ctyp{int} & Stampa un numero intero in formato decimale
+ con segno.\\
+ \cmd{\%i} &\ctyp{int} & Identico a \cmd{\%i} in output.\\
+ \cmd{\%o} &\ctyp{unsigned int}& Stampa un numero intero come ottale.\\
+ \cmd{\%u} &\ctyp{unsigned int}& Stampa un numero intero in formato
+ decimale senza segno.\\
+ \cmd{\%x},
+ \cmd{\%X} &\ctyp{unsigned int}& Stampano un intero in formato esadecimale,
+ rispettivamente con lettere minuscole e
+ maiuscole.\\
+ \cmd{\%f} &\ctyp{double} & Stampa un numero in virgola mobile con la
+ notazione a virgola fissa.\\
+ \cmd{\%e},
+ \cmd{\%E} &\ctyp{double} & Stampano un numero in virgola mobile con la
+ notazione esponenziale, rispettivamente con
+ lettere minuscole e maiuscole.\\
+ \cmd{\%g},
+ \cmd{\%G} &\ctyp{double} & Stampano un numero in virgola mobile con la
+ notazione più appropriate delle due precedenti,
+ rispettivamente con lettere minuscole e
+ maiuscole.\\
+ \cmd{\%a},
+ \cmd{\%A} &\ctyp{double} & Stampano un numero in virgola mobile in
+ notazione esadecimale frazionaria.\\
+ \cmd{\%c} &\ctyp{int} & Stampa un carattere singolo.\\
+ \cmd{\%s} &\ctyp{char *} & Stampa una stringa.\\
+ \cmd{\%p} &\ctyp{void *} & Stampa il valore di un puntatore.\\
+ \cmd{\%n} &\ctyp{\&int} & Prende il numero di caratteri stampati finora.\\
+ \cmd{\%\%}& & Stampa un \%.\\
+ \hline
+ \end{tabular}
+ \caption{Valori possibili per gli specificatori di conversione in una
+ stringa di formato di \func{printf}.}
+ \label{tab:file_format_spec}
+\end{table}
+
+La stringa è costituita da caratteri normali (tutti eccetto \texttt{\%}), che
+vengono passati invariati all'output, e da direttive di conversione, in cui
+devono essere sempre presenti il carattere \texttt{\%}, che introduce la
+direttiva, ed uno degli specificatori di conversione (riportati in
+tab.~\ref{tab:file_format_spec}) che la conclude.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato}\\
+ \hline
+ \hline
+ \val{\#} & Chiede la conversione in forma alternativa. \\
+ \val{0} & La conversione è riempita con zeri alla sinistra del valore.\\
+ \val{-} & La conversione viene allineata a sinistra sul bordo del campo.\\
+ \val{' '}& Mette uno spazio prima di un numero con segno di valore
+ positivo.\\
+ \val{+} & Mette sempre il segno ($+$ o $-$) prima di un numero.\\
+ \hline
+ \end{tabular}
+ \caption{I valori dei flag per il formato di \func{printf}}
+ \label{tab:file_format_flag}
+\end{table}
+
+Il formato di una direttiva di conversione prevede una serie di possibili
+elementi opzionali oltre al \cmd{\%} e allo specificatore di conversione. In
+generale essa è sempre del tipo:
+\begin{center}
+\begin{verbatim}
+% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
+\end{verbatim}
+\end{center}
+in cui tutti i valori tranne il \val{\%} e lo specificatore di conversione
+sono opzionali (e per questo sono indicati fra parentesi quadre); si possono
+usare più elementi opzionali, nel qual caso devono essere specificati in
+questo ordine:
+\begin{itemize*}
+\item uno specificatore del parametro da usare (terminato da un \val{\$}),
+\item uno o più flag (i cui valori possibili sono riassunti in
+ tab.~\ref{tab:file_format_flag}) che controllano il formato di stampa della
+ conversione,
+\item uno specificatore di larghezza (un numero decimale), eventualmente
+ seguito (per i numeri in virgola mobile) da un specificatore di precisione
+ (un altro numero decimale),
+\item uno specificatore del tipo di dato, che ne indica la dimensione (i cui
+ valori possibili sono riassunti in tab.~\ref{tab:file_format_type}).
+\end{itemize*}
+
+
+Dettagli ulteriori sulle varie opzioni possono essere trovati nella pagina di
+manuale di \func{printf} e nella documentazione delle \acr{glibc}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{10cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \cmd{hh} & Una conversione intera corrisponde a un \ctyp{char} con o senza
+ segno, o il puntatore per il numero dei parametri \cmd{n} è di
+ tipo \ctyp{char}.\\
+ \cmd{h} & Una conversione intera corrisponde a uno \ctyp{short} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{short}.\\
+ \cmd{l} & Una conversione intera corrisponde a un \ctyp{long} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{long}, o il carattere o la stringa seguenti
+ sono in formato esteso.\\
+ \cmd{ll} & Una conversione intera corrisponde a un \ctyp{long long} con o
+ senza segno, o il puntatore per il numero dei parametri \cmd{n}
+ è di tipo \ctyp{long long}.\\
+ \cmd{L} & Una conversione in virgola mobile corrisponde a un
+ \ctyp{double}.\\
+ \cmd{q} & Sinonimo di \cmd{ll}.\\
+ \cmd{j} & Una conversione intera corrisponde a un \type{intmax\_t} o
+ \type{uintmax\_t}.\\
+ \cmd{z} & Una conversione intera corrisponde a un \type{size\_t} o
+ \type{ssize\_t}.\\
+ \cmd{t} & Una conversione intera corrisponde a un \type{ptrdiff\_t}.\\
+ \hline
+ \end{tabular}
+ \caption{Il modificatore di tipo di dato per il formato di \func{printf}}
+ \label{tab:file_format_type}
+\end{table}
+
+Una versione alternativa delle funzioni di output formattato, che permettono
+di usare il puntatore ad una lista di argomenti (vedi
+sez.~\ref{sec:proc_variadic}), sono \funcd{vprintf}, \funcd{vfprintf} e
+\funcd{vsprintf}, i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int vprintf(const char *format, va\_list ap)} Stampa su
+ \var{stdout} gli argomenti della lista \param{ap}, secondo il formato
+ specificato da \param{format}.
+
+ \funcdecl{int vfprintf(FILE *stream, const char *format, va\_list ap)}
+ Stampa su \param{stream} gli argomenti della lista \param{ap}, secondo il
+ formato specificato da \param{format}.
+
+ \funcdecl{int vsprintf(char *str, const char *format, va\_list ap)} Stampa
+ sulla stringa \param{str} gli argomenti della lista \param{ap}, secondo il
+ formato specificato da \param{format}.
+
+ \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
+\end{functions}
+\noindent con queste funzioni diventa possibile selezionare gli argomenti che
+si vogliono passare ad una funzione di stampa, passando direttamente la lista
+tramite l'argomento \param{ap}. Per poter far questo ovviamente la lista degli
+argomenti dovrà essere opportunamente trattata (l'argomento è esaminato in
+sez.~\ref{sec:proc_variadic}), e dopo l'esecuzione della funzione l'argomento
+\param{ap} non sarà più utilizzabile (in generale dovrebbe essere eseguito un
+\code{va\_end(ap)} ma in Linux questo non è necessario).
+
+Come per \func{sprintf} anche per \func{vsprintf} esiste una analoga
+\funcd{vsnprintf} che pone un limite sul numero di caratteri che vengono
+scritti sulla stringa di destinazione:
+\begin{prototype}{stdio.h}
+{vsnprintf(char *str, size\_t size, const char *format, va\_list ap)}
+ Identica a \func{vsprintf}, ma non scrive su \param{str} più di
+ \param{size} caratteri.
+\end{prototype}
+\noindent in modo da evitare possibili \itindex{buffer~overflow} buffer
+overflow.
+
+
+Per eliminare alla radice questi problemi, le \acr{glibc} supportano una
+specifica estensione GNU che alloca dinamicamente tutto lo spazio necessario;
+l'estensione si attiva al solito definendo \macro{\_GNU\_SOURCE}, le due
+funzioni sono \funcd{asprintf} e \funcd{vasprintf}, ed i rispettivi prototipi
+sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int asprintf(char **strptr, const char *format, ...)} Stampa gli
+ argomenti specificati secondo il formato specificato da \param{format} su
+ una stringa allocata automaticamente all'indirizzo \param{*strptr}.
+
+ \funcdecl{int vasprintf(char **strptr, const char *format, va\_list ap)}
+ Stampa gli argomenti della lista \param{ap} secondo il formato specificato
+ da \param{format} su una stringa allocata automaticamente all'indirizzo
+ \param{*strptr}.
+
+ \bodydesc{Le funzioni ritornano il numero di caratteri stampati.}
+\end{functions}
+
+Entrambe le funzioni prendono come argomento \param{strptr} che deve essere
+l'indirizzo di un puntatore ad una stringa di caratteri, in cui verrà
+restituito (si ricordi quanto detto in sez.~\ref{sec:proc_var_passing} a
+proposito dei \itindex{value~result~argument} \textit{value result argument})
+l'indirizzo della stringa allocata automaticamente dalle funzioni. Occorre
+inoltre ricordarsi di invocare \func{free} per liberare detto puntatore quando
+la stringa non serve più, onde evitare \itindex{memory~leak} \textit{memory
+ leak}.
+
+Infine una ulteriore estensione GNU definisce le due funzioni \func{dprintf} e
+\func{vdprintf}, che prendono un file descriptor al posto dello stream. Altre
+estensioni permettono di scrivere con caratteri estesi. Anche queste funzioni,
+il cui nome è generato dalle precedenti funzioni aggiungendo una \texttt{w}
+davanti a \texttt{print}, sono trattate in dettaglio nella documentazione delle
+\acr{glibc}.
+
+In corrispondenza alla famiglia di funzioni \func{printf} che si usano per
+l'output formattato, l'input formattato viene eseguito con le funzioni della
+famiglia \func{scanf}; fra queste le tre più importanti sono \funcd{scanf},
+\funcd{fscanf} e \funcd{sscanf}, i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h} \funcdecl{int scanf(const char *format, ...)} Esegue una
+ scansione di \file{stdin} cercando una corrispondenza di quanto letto con il
+ formato dei dati specificato da \param{format}, ed effettua le relative
+ conversione memorizzando il risultato negli argomenti seguenti.
+
+ \funcdecl{int fscanf(FILE *stream, const char *format, ...)} Analoga alla
+ precedente, ma effettua la scansione su \param{stream}.
+
+ \funcdecl{int sscanf(char *str, const char *format, ...)} Analoga alle
+ precedenti, ma effettua la scansione dalla stringa \param{str}.
+
+ \bodydesc{Le funzioni ritornano il numero di elementi assegnati. Questi
+ possono essere in numero inferiore a quelli specificati, ed anche zero.
+ Quest'ultimo valore significa che non si è trovata corrispondenza. In caso
+ di errore o fine del file viene invece restituito \val{EOF}.}
+\end{functions}
+\noindent e come per le analoghe funzioni di scrittura esistono le relative
+\func{vscanf}, \func{vfscanf} \func{vsscanf} che usano un puntatore ad una
+lista di argomenti.
+
+Tutte le funzioni della famiglia delle \func{scanf} vogliono come argomenti i
+puntatori alle variabili che dovranno contenere le conversioni; questo è un
+primo elemento di disagio in quanto è molto facile dimenticarsi di questa
+caratteristica.
+
+Le funzioni leggono i caratteri dallo stream (o dalla stringa) di input ed
+eseguono un confronto con quanto indicato in \param{format}, la sintassi di
+questo argomento è simile a quella usata per l'analogo di \func{printf}, ma ci
+sono varie differenze. Le funzioni di input infatti sono più orientate verso
+la lettura di testo libero che verso un input formattato in campi fissi. Uno
+spazio in \param{format} corrisponde con un numero qualunque di caratteri di
+separazione (che possono essere spazi, tabulatori, virgole ecc.), mentre
+caratteri diversi richiedono una corrispondenza esatta. Le direttive di
+conversione sono analoghe a quelle di \func{printf} e si trovano descritte in
+dettaglio nelle pagine di manuale e nel manuale delle \acr{glibc}.
+
+Le funzioni eseguono la lettura dall'input, scartano i separatori (e gli
+eventuali caratteri diversi indicati dalla stringa di formato) effettuando le
+conversioni richieste; in caso la corrispondenza fallisca (o la funzione non
+sia in grado di effettuare una delle conversioni richieste) la scansione viene
+interrotta immediatamente e la funzione ritorna lasciando posizionato lo
+stream al primo carattere che non corrisponde.
+
+Data la notevole complessità di uso di queste funzioni, che richiedono molta
+cura nella definizione delle corrette stringhe di formato e sono facilmente
+soggette ad errori, e considerato anche il fatto che è estremamente macchinoso
+recuperare in caso di fallimento nelle corrispondenze, l'input formattato non
+è molto usato. In genere infatti quando si ha a che fare con un input
+relativamente semplice si preferisce usare l'input di linea ed effettuare
+scansione e conversione di quanto serve direttamente con una delle funzioni di
+conversione delle stringhe; se invece il formato è più complesso diventa più
+facile utilizzare uno strumento come \cmd{flex}\footnote{il programma
+ \cmd{flex}, è una implementazione libera di \cmd{lex} un generatore di
+ analizzatori lessicali. Per i dettagli si può fare riferimento al manuale
+ \cite{flex}.} per generare un analizzatore lessicale o il
+\cmd{bison}\footnote{il programma \cmd{bison} è un clone del generatore di
+ parser \cmd{yacc}, maggiori dettagli possono essere trovati nel relativo
+ manuale \cite{bison}.} per generare un parser.
+
+
+\subsection{Posizionamento su uno stream}
+\label{sec:file_fseek}
+
+Come per i file descriptor anche per gli stream è possibile spostarsi
+all'interno di un file per effettuare operazioni di lettura o scrittura in un
+punto prestabilito; sempre che l'operazione di riposizionamento sia supportata
+dal file sottostante lo stream, quando cioè si ha a che fare con quello che
+viene detto un file ad \textsl{accesso casuale}.\footnote{dato che in un
+ sistema Unix esistono vari tipi di file, come le fifo ed i
+ \index{file!di~dispositivo} file di dispositivo, non è scontato che questo
+ sia sempre vero.}
+
+In GNU/Linux ed in generale in ogni sistema unix-like la posizione nel file è
+espressa da un intero positivo, rappresentato dal tipo \type{off\_t}, il
+problema è che alcune delle funzioni usate per il riposizionamento sugli
+stream originano dalle prime versioni di Unix, in cui questo tipo non era
+ancora stato definito, e che in altri sistemi non è detto che la posizione su
+un file venga sempre rappresentata con il numero di caratteri dall'inizio (ad
+esempio in VMS può essere rappresentata come numero di record, più l'offset
+rispetto al record corrente).
+
+Tutto questo comporta la presenza di diverse funzioni che eseguono
+sostanzialmente le stesse operazioni, ma usano argomenti di tipo diverso. Le
+funzioni tradizionali usate per il riposizionamento della posizione in uno
+stream sono \funcd{fseek} e \funcd{rewind} i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int fseek(FILE *stream, long offset, int whence)} Sposta la
+ posizione nello stream secondo quanto specificato tramite \param{offset}
+ e \param{whence}.
+
+ \funcdecl{void rewind(FILE *stream)} Riporta la posizione nello stream
+ all'inizio del file.
+\end{functions}
+
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor, e gli argomenti, a parte il tipo, hanno lo stesso significato; in
+particolare \param{whence} assume gli stessi valori già visti in
+sez.~\ref{sec:file_lseek}. La funzione restituisce 0 in caso di successo e -1
+in caso di errore. La funzione \func{rewind} riporta semplicemente la
+posizione corrente all'inizio dello stream, ma non esattamente equivalente ad
+una \code{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
+flag di errore e fine del file.
+
+Per ottenere la posizione corrente si usa invece la funzione \funcd{ftell}, il
+cui prototipo è:
+\begin{prototype}{stdio.h}{long ftell(FILE *stream)}
+ Legge la posizione attuale nello stream \param{stream}.
+
+ \bodydesc{La funzione restituisce la posizione corrente, o -1 in caso
+ di fallimento, che può esser dovuto sia al fatto che il file non
+ supporta il riposizionamento che al fatto che la posizione non può
+ essere espressa con un \ctyp{long int}}
+\end{prototype}
+\noindent la funzione restituisce la posizione come numero di byte
+dall'inizio dello stream.
+
+Queste funzioni esprimono tutte la posizione nel file come un \ctyp{long int}.
+Dato che (ad esempio quando si usa un filesystem indicizzato a 64 bit) questo
+può non essere possibile lo standard POSIX ha introdotto le nuove funzioni
+\funcd{fgetpos} e \funcd{fsetpos}, che invece usano il nuovo tipo
+\type{fpos\_t}, ed i cui prototipi sono:
+\begin{functions}
+ \headdecl{stdio.h}
+
+ \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Imposta la posizione
+ corrente nello stream \param{stream} al valore specificato da \param{pos}.
+
+ \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Legge la posizione
+ corrente nello stream \param{stream} e la scrive in \param{pos}.
+
+ \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
+ errore.}
+\end{functions}
+
+In Linux, a partire dalle glibc 2.1, sono presenti anche le due funzioni
+\func{fseeko} e \func{ftello}, che sono assolutamente identiche alle
+precedenti \func{fseek} e \func{ftell} ma hanno argomenti di tipo
+\type{off\_t} anziché di tipo \ctyp{long int}. Dato che \ctyp{long} è nella
+gran parte dei casi un intero a 32 bit, questo diventa un problema quando la
+posizione sul file viene espressa con un valore a 64 bit come accade nei
+sistemi più moderni.