filesystem \textit{proc} con l'apertura del file attraverso il riferimento a
\textit{pathname} del tipo di \texttt{/proc/self/fd/dirfd/relative\_path}.}
Benché queste funzioni non siano presenti negli standard tradizionali esse
-sono state adottate da altri sistemi unix-like com Solaris i vari BSD, fino ad
+sono state adottate da altri sistemi unix-like come Solaris i vari BSD, fino ad
essere incluse in una recente revisione (la POSIX.1-2008) dello standard
POSIX.1. Con la \acr{glibc} per l'accesso a queste funzioni è necessario
definire la macro \macro{\_ATFILE\_SOURCE}.
La seconda eccezione è \funcd{unlinkat}, in questo caso
l'argomento \param{flags} viene utilizzato perché tramite esso si può indicare
-alla fuzione di comportarsi sia come analogo di \func{unlink} che di
+alla funzione di comportarsi sia come analogo di \func{unlink} che di
\func{rmdir}; il suo prototipo è:
\begin{funcproto}{
\textbf{Costante} & \textbf{Significato} \\
\hline
\hline
- \const{AT\_SYMLINK\_NOFOLLOW}& se impostato la funzione non esegue la
+ \const{AT\_SYMLINK\_NOFOLLOW}& Se impostato la funzione non esegue la
dereferenziazione dei collegamenti simbolici.\\
- \const{AT\_SYMLINK\_FOLLOW}& se impostato la funzione esegue la
+ \const{AT\_SYMLINK\_FOLLOW}& Se impostato la funzione esegue la
dereferenziazione dei collegamenti simbolici
(usato esplicitamente solo da \func{linkat}).\\
- \const{AT\_EACCES} & usato solo da \func{faccessat}, richiede che
+ \const{AT\_EACCES} & Usato solo da \func{faccessat}, richiede che
il controllo dei permessi sia fatto usando
l'\ids{UID} effettivo invece di quello
reale.\\
- \const{AT\_REMOVEDIR} & usato solo da \func{unlinkat}, richiede che
+ \const{AT\_REMOVEDIR} & Usato solo da \func{unlinkat}, richiede che
la funzione si comporti come \func{rmdir}
invece che come \func{unlink}.\\
\hline
\errcode{EPERM} se si cerca di rimuovere \const{O\_APPEND} da un file
marcato come \textit{append-only} o se di cerca di impostare
\const{O\_NOATIME} su un file di cui non si è proprietari (e non si hanno i
- permessi di amministatore) ed \errcode{EINVAL} se si cerca di impostare
+ permessi di amministratore) ed \errcode{EINVAL} se si cerca di impostare
\const{O\_DIRECT} su un file che non supporta questo tipo di operazioni.
\item[\const{F\_GETLK}] richiede un controllo sul file lock specificato da
processo, nel caso di un \textit{process group} viene restituito un valore
negativo il cui valore assoluto corrisponde all'identificatore del
\itindex{process~group} \textit{process group}. Con Linux questo comporta un
- problema perché se il valore restitituito dalla \textit{system call} è
+ problema perché se il valore restituito dalla \textit{system call} è
compreso nell'intervallo fra $-1$ e $-4095$ in alcune architetture questo
viene trattato dalla \acr{glibc} come un errore,\footnote{il problema deriva
dalle limitazioni presenti in architetture come quella dei normali PC
\itindex{process~group} \textit{process group}.
\item[\const{F\_GETOWN\_EX}] legge nella struttura puntata
- dal'argomento \param{owner} l'identificatore del processo, \textit{thread} o
+ dall'argomento \param{owner} l'identificatore del processo, \textit{thread} o
\itindex{process~group} \textit{process group} (vedi
sez.~\ref{sec:sess_proc_group}) che è preposto alla ricezione dei segnali
\signal{SIGIO} e \signal{SIGURG} per gli eventi associati al file
Come \const{F\_GETOWN\_EX} il comando richiede come terzo argomento il
puntatore ad una struttura \struct{f\_owner\_ex} la cui definizione è
riportata in fig.~\ref{fig:f_owner_ex}, in cui il primo campo indica il tipo
- di indentificatore il cui valore è specificato nel secondo campo, che assume
+ di identificatore il cui valore è specificato nel secondo campo, che assume
lo stesso significato di \param{arg} per \const{F\_SETOWN}. Per il campo
\var{type} i soli valori validi sono \const{F\_OWNER\_TID},
\const{F\_OWNER\_PID} e \const{F\_OWNER\_PGRP}, che indicano rispettivamente
- che si intedende specificare con \var{pid} un \textit{Tread ID}, un
+ che si intende specificare con \var{pid} un \textit{Tread ID}, un
\textit{Process ID} o un \textit{Process Group ID}. A differenza di
\const{F\_SETOWN} se si specifica un \textit{Tread ID} questo riceverà sia
\signal{SIGIO} (o il segnale impostato con \const{F\_SETSIG}) che
\errval{EBADF} si otterrà \errcode{EINVAL} se si è specificato un valore non
valido per \param{arg} (deve essere usato uno dei valori di
tab.~\ref{tab:file_lease_fctnl}), \errcode{ENOMEM} se non c'è memoria
- sufficiente per creare il \textit{file lease}, \errcode{EACCESS} se non si è
+ sufficiente per creare il \textit{file lease}, \errcode{EACCES} se non si è
il proprietario del file e non si hanno i privilegi di
amministratore.\footnote{per la precisione occorre la capacità
\itindex{capabilities} \const{CAP\_LEASE}.}
nullo in caso di successo o $-1$ in caso di errore. Oltre a \errval{EBADF}
gli errori possibili sono \errcode{EBUSY} se si cerca di ridurre la
dimensione del buffer al di sotto della quantità di dati effettivamente
- presenti su di esso ed \errcode{EPERM} se un processo non priviligiato cerca
+ presenti su di esso ed \errcode{EPERM} se un processo non privilegiato cerca
di impostare un valore troppo alto. La dimensione minima del buffer è pari
ad una pagina di memoria, a cui verrà comunque arrotondata ogni dimensione
inferiore, il valore specificato viene in genere arrotondato per eccesso al
La funzione richiede che si passi come primo argomento un file
descriptor \param{fd} regolarmente aperto, mentre l'operazione da compiere
-deve essere incata dal valore dell'argomento \param{request}. Il terzo
+deve essere indicata dal valore dell'argomento \param{request}. Il terzo
argomento dipende dall'operazione prescelta; tradizionalmente è specificato
come \code{char * argp}, da intendersi come puntatore ad un area di memoria
generica (all'epoca della creazione di questa funzione infatti ancora non era
queste, insieme alle altre funzioni definite dallo standard (queste funzioni
sono state implementate la prima volta da Ritchie nel 1976 e da allora sono
rimaste sostanzialmente immutate), vengono a costituire il nucleo delle
-\acr{glibc}.
+\acr{glibc} per la gestione dei file.
Esamineremo in questa sezione le funzioni base dell'interfaccia degli
all'ottenimento della massima efficienza.
Per questo motivo l'interfaccia viene chiamata anche interfaccia dei
-\textit{file stream}, dato che non è più necessario doversi preoccupare
-dei dettagli della comunicazione con il tipo di hardware sottostante
-(come nel caso della dimensione dei blocchi del filesystem), ed un file
-può essere sempre considerato come composto da un flusso continuo (da
-cui il nome \textit{stream}) di dati.
+\textit{file stream}, dato che non è più necessario doversi preoccupare dei
+dettagli con cui viene gestita la comunicazione con l'hardware sottostante
+(come nel caso della dimensione dei blocchi del filesystem), ed un file può
+essere sempre considerato come composto da un flusso continuo di dati, da cui
+deriva appunto il nome \textit{stream}.
A parte i dettagli legati alla gestione delle operazioni di lettura e
-scrittura (sia per quel che riguarda la bufferizzazione, che le
-formattazioni), i \textit{file stream} restano del tutto equivalenti ai file
-descriptor (sui quali sono basati), ed in particolare continua a valere quanto
-visto in sez.~\ref{sec:file_shared_access} a proposito dell'accesso
+scrittura, sia per quel che riguarda la bufferizzazione, che le formattazioni,
+per tutto il resto i \textit{file stream} restano del tutto equivalenti ai
+file descriptor (sui quali sono basati), ed in particolare continua a valere
+quanto visto in sez.~\ref{sec:file_shared_access} a proposito dell'accesso
concorrente ed in sez.~\ref{sec:file_access_control} per il controllo di
accesso.
\itindend{file~stream}
-
Per ragioni storiche la struttura di dati che rappresenta uno \textit{stream}
è stata chiamata \type{FILE}, questi oggetti sono creati dalle funzioni di
libreria e contengono tutte le informazioni necessarie a gestire le operazioni
Per questo motivo gli utenti non devono mai utilizzare direttamente o allocare
queste strutture (che sono dei \index{tipo!opaco} \textsl{tipi opachi}) ma
-usare sempre puntatori del tipo \texttt{FILE *} ottenuti dalla libreria stessa
-(tanto che in certi casi il termine di puntatore a file è diventato sinonimo
-di \textit{stream}). Tutte le funzioni della libreria che operano sui file
-accettano come argomenti solo variabili di questo tipo, che diventa
+usare sempre puntatori del tipo \texttt{FILE *} ottenuti dalla libreria
+stessa, tanto che in certi casi il termine di puntatore a file è diventato
+sinonimo di \textit{stream}. Tutte le funzioni della libreria che operano sui
+file accettano come argomenti solo variabili di questo tipo, che diventa
accessibile includendo l'header file \headfile{stdio.h}.
Ai tre file descriptor standard (vedi tab.~\ref{tab:file_std_files}) aperti
I dati che vengono scritti su di uno \textit{stream} normalmente vengono
accumulati in un buffer e poi trasmessi in blocco, con l'operazione che viene
-usualmente chiamata \textsl{scaricamento}, (dal termine inglese
-\textit{flush}) tutte le volte che il buffer viene riempito, in maniera
-asincrona rispetto alla scrittura. Un comportamento analogo avviene anche in
-lettura (cioè dal file viene letto un blocco di dati, anche se ne sono
-richiesti una quantità inferiore), ma la cosa ovviamente ha rilevanza
-inferiore, dato che i dati letti sono sempre gli stessi. In caso di scrittura
-invece, quando si ha un accesso contemporaneo allo stesso file (ad esempio da
-parte di un altro processo) si potranno vedere solo le parti effettivamente
-scritte, e non quelle ancora presenti nel buffer.
+usualmente chiamata \textsl{scaricamento} del buffer (dal termine inglese
+\textit{flush}) tutte le volte che questo viene riempito. Questa operazione
+avviene perciò in maniera asincrona rispetto alla scrittura. Un comportamento
+analogo avviene anche in lettura (cioè dal file viene letto un blocco di dati,
+anche se ne sono richiesti una quantità inferiore), ma la cosa ovviamente ha
+rilevanza inferiore, dato che i dati letti sono sempre gli stessi. In caso di
+scrittura invece, quando si ha un accesso contemporaneo allo stesso file (ad
+esempio da parte di un altro processo) si potranno vedere solo le parti
+effettivamente scritte, e non quelle ancora presenti nel buffer.
Per lo stesso motivo, in tutte le situazioni in cui si sta facendo
dell'input/output interattivo, bisognerà tenere presente le caratteristiche
delle operazioni di scaricamento dei dati, poiché non è detto che ad una
scrittura sullo \textit{stream} corrisponda una immediata scrittura sul
-dispositivo (la cosa è particolarmente evidente quando con le operazioni di
-input/output su terminale).
+dispositivo, e la cosa è particolarmente evidente con le operazioni di
+input/output sul terminale.
-Per rispondere ad esigenze diverse, lo standard definisce tre distinte
-modalità in cui può essere eseguita la bufferizzazione, delle quali
-occorre essere ben consapevoli, specie in caso di lettura e scrittura da
-dispositivi interattivi:
+Per rispondere ad esigenze diverse lo standard definisce tre distinte modalità
+in cui può essere eseguita la bufferizzazione, delle quali occorre essere ben
+consapevoli, specie in caso di lettura e scrittura da dispositivi interattivi:
\begin{itemize}
\item \textit{unbuffered}: in questo caso non c'è bufferizzazione ed i
caratteri vengono trasmessi direttamente al file non appena possibile
(effettuando immediatamente una \func{write});
-\item \textit{line buffered}: in questo caso i caratteri vengono
- normalmente trasmessi al file in blocco ogni volta che viene
- incontrato un carattere di \textit{newline} (il carattere ASCII
- \verb|\n|);
+\item \textit{line buffered}: in questo caso i caratteri vengono normalmente
+ trasmessi al file in blocco ogni volta che viene incontrato un carattere di
+ \textit{newline} (il carattere ASCII \verb|\n|) cioè un a capo (in sostanza
+ quando si preme invio);
\item \textit{fully buffered}: in questo caso i caratteri vengono
trasmessi da e verso il file in blocchi di dimensione opportuna.
\end{itemize}
Linux, come BSD e SVr4, specifica il comportamento predefinito in maniera
ancora più precisa, e cioè impone che lo standard error sia sempre
-\textit{unbuffered} (in modo che i messaggi di errore siano mostrati il più
-rapidamente possibile) e che \itindex{standard~input} \textit{standard input}
+\textit{unbuffered}, in modo che i messaggi di errore siano mostrati il più
+rapidamente possibile, e che \itindex{standard~input} \textit{standard input}
e \itindex{standard~output} \textit{standard output} siano aperti in modalità
\textit{line buffered} quando sono associati ad un terminale (od altro
dispositivo interattivo) ed in modalità \textit{fully buffered} altrimenti.
La modalità \textit{line buffered} è quella che necessita di maggiori
chiarimenti e attenzioni per quel che concerne il suo funzionamento. Come già
accennato nella descrizione, \emph{di norma} i dati vengono inviati al kernel
-alla ricezione di un carattere di \textsl{a capo} (\textit{newline}); questo
-non è vero in tutti i casi, infatti, dato che le dimensioni del buffer usato
-dalle librerie sono fisse, se le si eccedono si può avere uno scarico dei dati
-anche prima che sia stato inviato un carattere di \textit{newline}.
+alla ricezione di un carattere di \textsl{a capo} (il \textit{newline});
+questo non è vero in tutti i casi, infatti, dato che le dimensioni del buffer
+usato dalle librerie sono fisse, se le si eccedono si può avere uno scarico
+dei dati anche prima che sia stato inviato un carattere di \textit{newline}.
Un secondo punto da tenere presente, particolarmente quando si ha a che fare
con I/O interattivo, è che quando si effettua una lettura da uno
-\textit{stream} che comporta l'accesso al kernel\footnote{questo vuol dire che
- lo \textit{stream} da cui si legge è in modalità \textit{unbuffered}.} viene
-anche eseguito lo scarico di tutti i buffer degli \textit{stream} in
-scrittura.
-
-In sez.~\ref{sec:file_buffering_ctrl} vedremo come la libreria definisca delle
-opportune funzioni per controllare le modalità di bufferizzazione e lo scarico
-dei dati.
-
+\textit{stream} che comporta l'accesso alle \textit{system call} del kernel,
+ad esempio se lo \textit{stream} da cui si legge è in modalità
+\textit{unbuffered}, viene anche eseguito lo scarico di tutti i buffer degli
+\textit{stream} in scrittura. In sez.~\ref{sec:file_buffering_ctrl} vedremo
+come la libreria definisca delle opportune funzioni per controllare le
+modalità di bufferizzazione e lo scarico dei dati.
Le funzioni che si possono usare per aprire uno \textit{stream} sono solo tre:
\funcd{fopen}, \funcd{fdopen} e \funcd{freopen},\footnote{\func{fopen} e
\func{freopen} fanno parte dello standard ANSI C, \func{fdopen} è parte
- dello standard POSIX.1.} i loro prototipi sono:
+ dello standard POSIX.1.} ed i rispettivi prototipi sono:
\begin{funcproto}{
\fhead{stdio.h}
\func{freopen}.}
\end{funcproto}
-
Normalmente la funzione che si usa per aprire uno \textit{stream} è
\func{fopen}, essa apre il file specificato dal \textit{pathname} \param{path}
nella modalità specificata da \param{mode}, che è una stringa che deve
-iniziare con almeno uno dei valori indicati in tab.~\ref{tab:file_fopen_mode}
-(sono possibili varie estensioni che vedremo in seguito).
+iniziare con almeno uno dei valori indicati in tab.~\ref{tab:file_fopen_mode},
+anche se sono possibili varie estensioni che vedremo in seguito.
L'uso più comune di \func{freopen} è per redirigere uno dei tre file standard
(vedi sez.~\ref{sec:file_stream}): il file \param{path} viene aperto nella
-modalità indicata da \param{mode} ed associato allo \textit{stream}
-a \param{stream}, e se questo era uno \textit{stream} già aperto viene
-preventivamente chiuso.
+modalità indicata da \param{mode} ed associato allo \textit{stream} indicato
+dall'argomento \param{stream}, e se questo era uno \textit{stream} già aperto
+esso viene preventivamente chiuso e tutti i dati pendenti vengono scaricati.
Infine \func{fdopen} viene usata per associare uno \textit{stream} ad un file
descriptor esistente ottenuto tramite una altra funzione (ad esempio con una
Le \acr{glibc} supportano alcune estensioni, queste devono essere sempre
indicate dopo aver specificato il \param{mode} con uno dei valori di
tab.~\ref{tab:file_fopen_mode}. L'uso del carattere \texttt{x} serve per
-evitare di sovrascrivere un file già esistente (è analoga all'uso
-dell'opzione \const{O\_EXCL} in \func{open}), se il file specificato già
-esiste e si aggiunge questo carattere a \param{mode} la \func{fopen}
-fallisce.
+evitare di sovrascrivere un file già esistente (è analoga all'uso dell'opzione
+\const{O\_EXCL} in \func{open}): se il file specificato già esiste e si
+aggiunge questo carattere a \param{mode} la \func{fopen} fallisce.
Un'altra estensione serve a supportare la localizzazione, quando si
aggiunge a \param{mode} una stringa della forma \verb|",ccs=STRING"| il
Inoltre i modi \cmd{w} e \cmd{w+} non troncano il file. La posizione nello
\textit{stream} viene impostata a quella corrente nel file descriptor, e le
variabili di errore e di fine del file (vedi sez.~\ref{sec:file_io}) sono
-cancellate. Il file non viene duplicato e verrà chiuso alla chiusura dello
-\textit{stream}.
+cancellate. Il file non viene duplicato e verrà chiuso automaticamente alla
+chiusura dello \textit{stream}.
I nuovi file saranno creati secondo quanto visto in
sez.~\ref{sec:file_ownership_management} ed avranno i permessi di accesso
impostati al valore
\code{S\_IRUSR|S\_IWUSR|S\_IRGRP|S\_IWGRP|S\_IROTH|S\_IWOTH} (pari a
-\val{0666}) modificato secondo il valore di \itindex{umask} \textit{umask} per
-il processo (si veda sez.~\ref{sec:file_perm_management}).
+\val{0666}) modificato secondo il valore della \itindex{umask} \textit{umask}
+per il processo (si veda sez.~\ref{sec:file_perm_management}). Una volta
+aperto lo \textit{stream}, si può cambiare la modalità di bufferizzazione (si
+veda sez.~\ref{sec:file_buffering_ctrl}) fintanto che non si è effettuato
+alcuna operazione di I/O sul file.
In caso di file aperti in lettura e scrittura occorre ricordarsi che c'è
di mezzo una bufferizzazione; per questo motivo lo standard ANSI C
un'operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è
sufficiente a garantire la sincronizzazione.
-Una volta aperto lo \textit{stream}, si può cambiare la modalità di
-bufferizzazione (si veda sez.~\ref{sec:file_buffering_ctrl}) fintanto che non
-si è effettuato alcuna operazione di I/O sul file.
-
-Uno \textit{stream} viene chiuso con la funzione \funcd{fclose} il cui
-prototipo è:
+Una volta completate le operazioni su di esso \textit{stream} può essere
+chiuso con la funzione \funcd{fclose}, il cui prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
qual caso \var{errno} assumerà gli stessi valori di \func{fclose}.}
\end{funcproto}
- La funzione esegue lo scarico dei dati bufferizzati in uscita
- e scarta quelli in ingresso, chiudendo tutti i file. Questa funzione è
- provvista solo per i casi di emergenza, quando si è verificato un errore
- ed il programma deve essere abortito, ma si vuole compiere qualche altra
- operazione dopo aver chiuso i file e prima di uscire (si ricordi quanto
- visto in sez.~\ref{sec:proc_conclusion}).
+La funzione esegue lo scarico dei dati bufferizzati in uscita e scarta quelli
+in ingresso, chiudendo tutti i file. Questa funzione è provvista solo per i
+casi di emergenza, quando si è verificato un errore ed il programma deve
+essere abortito, ma si vuole compiere qualche altra operazione dopo aver
+chiuso i file e prima di uscire (si ricordi quanto visto in
+sez.~\ref{sec:proc_conclusion}).
- \subsection{Lettura e scrittura su uno \textit{stream}}
+\subsection{Gestione dell'I/O e posizionamento su uno \textit{stream}}
\label{sec:file_io}
Una delle caratteristiche più utili dell'interfaccia degli \textit{stream} è
la ricchezza delle funzioni disponibili per le operazioni di lettura e
scrittura sui file. Sono infatti previste ben tre diverse modalità modalità di
input/output non formattato:
- \begin{enumerate*}
- \item\textsl{binario} in cui legge/scrive un blocco di dati alla
- volta, vedi sez.~\ref{sec:file_binary_io}.
- \item\textsl{a caratteri} in cui si legge/scrive un carattere alla
- volta (con la bufferizzazione gestita automaticamente dalla libreria),
- vedi sez.~\ref{sec:file_char_io}.
- \item\textsl{di linea} in cui si legge/scrive una linea alla volta (terminata
- dal carattere di newline \verb|'\n'|), vedi sez.~\ref{sec:file_line_io}.
- \end{enumerate*}
- ed inoltre la modalità di input/output formattato.
-
- A differenza dell'interfaccia dei file descriptor, con gli \textit{stream} il
- raggiungimento della fine del file è considerato un errore, e viene
- notificato come tale dai valori di uscita delle varie funzioni. Nella
- maggior parte dei casi questo avviene con la restituzione del valore
- intero (di tipo \ctyp{int}) \val{EOF}\footnote{la costante deve essere
- negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
- valori diversi.} definito anch'esso nell'header \headfile{stdlib.h}.
+ \begin{itemize}
+ \item\textsl{binario} in cui si leggono e scrivono blocchi di dati di
+ dimensione arbitraria, (analogo della modalità ordinaria dell'I/O sui file
+ descriptor), trattato in sez.~\ref{sec:file_binary_io}.
+ \item\textsl{a caratteri} in cui si legge e scrive un carattere alla volta,
+ con la bufferizzazione che viene gestita automaticamente dalla libreria,
+ trattato in sez.~\ref{sec:file_char_io}.
+ \item\textsl{di linea} in cui si legge e scrive una linea alla volta,
+ (terminata dal carattere di newline \verb|'\n'|), trattato in
+ sez.~\ref{sec:file_line_io}.
+ \end{itemize}
+ a cui si aggiunge la modalità di input/output formattato, trattato in
+ sez.~\ref{sec:file_formatted_io}.
+
+ Ognuna di queste modalità utilizza per l'I/O delle funzioni specifiche che
+ vedremo nelle sezioni citate, affronteremo qui tutte gli argomenti e le
+ funzioni che si applicano in generale a tutte le modalità di I/O.
+
+ A differenza di quanto avviene con l'interfaccia dei file descriptor, con gli
+ \textit{stream} il raggiungimento della fine del file viene considerato un
+ errore, e viene notificato come tale dai valori di uscita delle varie
+ funzioni. Nella maggior parte dei casi questo avviene con la restituzione del
+ valore intero (di tipo \ctyp{int}) \val{EOF} definito anch'esso nell'header
+ \headfile{stdlib.h}. La costante deve essere negativa perché in molte
+ funzioni un valore positivo indica la quantità di dati scritti, le
+ \acr{glibc} usano il valore $-1$, ma altre implementazioni possono avere
+ valori diversi.
Dato che le funzioni dell'interfaccia degli \textit{stream} sono funzioni di
libreria che si appoggiano a delle \textit{system call}, esse non impostano
- direttamente la variabile \var{errno}, che mantiene il valore impostato dalla
- \textit{system call} che ha riportato l'errore.
+ direttamente la variabile \var{errno}, che mantiene sempre il valore
+ impostato dalla \textit{system call} invocata internamente che ha riportato
+ l'errore.
- Siccome la condizione di end-of-file è anch'essa segnalata come errore, nasce
- il problema di come distinguerla da un errore effettivo; basarsi solo sul
- valore di ritorno della funzione e controllare il valore di \var{errno}
- infatti non basta, dato che quest'ultimo potrebbe essere stato impostato in
- una altra occasione, (si veda sez.~\ref{sec:sys_errno} per i dettagli del
- funzionamento di \var{errno}).
+ Siccome la condizione di \textit{end-of-file} è anch'essa segnalata come
+ errore, nasce il problema di come distinguerla da un errore effettivo;
+ basarsi solo sul valore di ritorno della funzione e controllare il valore di
+ \var{errno} infatti non basta, dato che quest'ultimo potrebbe essere stato
+ impostato in una altra occasione, (si veda sez.~\ref{sec:sys_errno} per i
+ dettagli del funzionamento di \var{errno}).
Per questo motivo tutte le implementazioni delle librerie standard mantengono
per ogni \textit{stream} almeno due flag all'interno dell'oggetto \type{FILE},
impostati, e non prevedono condizioni di errore.}
\end{funcproto}
-\noindent si tenga presente comunque che la lettura di questi flag segnala
-soltanto che c'è stato un errore, o che si è raggiunta la fine del file in una
-qualunque operazione sullo \textit{stream}, il controllo quindi deve essere
-effettuato ogni volta che si chiama una funzione di libreria.
+Si tenga presente comunque che la lettura di questi flag segnala soltanto che
+c'è stato un errore o che si è raggiunta la fine del file in una qualunque
+operazione sullo \textit{stream}, il controllo su quanto avvenuto deve quindi
+essere effettuato ogni volta che si chiama una funzione di libreria.
Entrambi i flag (di errore e di \textit{end-of-file}) possono essere
cancellati usando la funzione \funcd{clearerr}, il cui prototipo è:
{La funzione non ritorna nulla e prevede condizioni di errore.}
\end{funcproto}
-\noindent in genere si usa questa funzione una volta che si sia identificata e
-corretta la causa di un errore per evitare di mantenere i flag attivi, così da
-poter rilevare una successiva ulteriore condizione di errore. Di questa
-funzione esiste una analoga \funcm{clearerr\_unlocked} che non esegue il
-blocco dello \textit{stream} (vedi sez.~\ref{sec:file_stream_thread}).
+In genere si usa questa funzione una volta che si sia identificata e corretta
+la causa di un errore per evitare di mantenere i flag attivi, così da poter
+rilevare una successiva ulteriore condizione di errore. Di questa funzione
+esiste una analoga \funcm{clearerr\_unlocked} (con lo stesso argomento e
+stessi valori di ritorno) che non esegue il blocco dello \textit{stream}
+(tratteremo il significato di blocco di uno \textit{stream} in
+sez.~\ref{sec:file_stream_thread}).
+
+Come per i file descriptor anche per gli \textit{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 \textit{stream}, nel caso cioè in cui si ha a che
+fare con quello che viene detto un file ad \textsl{accesso casuale}. Dato che
+in un sistema Unix esistono vari tipi di file, come le fifo ed i
+\index{file!di~dispositivo} file di dispositivo (ad esempio i terminali), non
+è scontato che questo sia vero in generale, pur essendolo sempre nel caso di
+file di dati.
+
+Con Linux ed in generale in ogni sistema unix-like la posizione nel file, come
+abbiamo già visto in sez.~\ref{sec:file_lseek}, è espressa da un intero
+positivo, rappresentato dal tipo \type{off\_t}. Il problema è che alcune delle
+funzioni usate per il riposizionamento sugli \textit{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 nel VMS dove
+esistono i file a record (in cui cioè l'I/O avviene per blocchi, i record, di
+dimensione fissa), essa può essere rappresentata come un 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 eseguire una modifica della posizione corrente
+sul file con uno \textit{stream} sono \funcd{fseek} e \funcd{rewind}, i
+rispettivi prototipi sono:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fseek(FILE *stream, long offset, int whence)}
+\fdesc{Sposta la posizione nello \textit{stream}.}
+\fdecl{void rewind(FILE *stream)}
+\fdesc{Riporta la posizione nello \textit{stream} all'inizio del file.}
+}
+
+{La funzione \func{fseek} ritorna $0$ in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek},
+ \func{rewind} non ritorna nulla e non ha condizioni di errore.}
+\end{funcproto}
+
+L'uso di \func{fseek} è del tutto analogo a quello di \func{lseek} per i file
+descriptor (vedi sez.~\ref{sec:file_lseek}). Anche gli argomenti, a parte il
+tipo, hanno esattamente lo stesso significato. In particolare \param{whence}
+deve assumere gli stessi valori già visti nella prima parte di
+tab.~\ref{tab:lseek_whence_values}. La funzione restituisce 0 in caso di
+successo e -1 in caso di errore.
+
+La funzione \func{rewind} riporta semplicemente la posizione corrente sul file
+all'inizio dello \textit{stream}, ma non è esattamente equivalente ad aver
+eseguito una \code{fseek(stream, 0L, SEEK\_SET)}, in quanto con l'uso della
+funzione vengono cancellati anche i flag di errore e di fine del file.
+
+Per ottenere la posizione corrente sul file di uno \textit{stream} lo standard
+ANSI C prescrive l'uso della funzione \funcd{ftell}, il cui prototipo è:
+
+\begin{funcproto}{
+\fhead{stdio.h}
+\fdecl{long ftell(FILE *stream)}
+\fdesc{Legge la posizione attuale nello \textit{stream}.}
+}
+
+{La funzione ritorna la posizione corrente in caso di successo e $-1$ per un
+ errore, nel qual caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+\noindent che restituisce la posizione come numero di byte dall'inizio dello
+\textit{stream}.
+
+Sia \func{fseek} che \func{ftell} esprimono la posizione nel file con un
+intero di tipo \ctyp{long}. Dato che in certi casi, ad esempio quando si usa
+un filesystem indicizzato a 64 bit su una macchina con architettura a 32 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{funcproto}{
+\fhead{stdio.h}
+\fdecl{int fsetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Imposta la posizione corrente sul file.}
+\fdecl{int fgetpos(FILE *stream, fpos\_t *pos)}
+\fdesc{Legge la posizione corrente sul file.}
+}
+
+{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
+ caso \var{errno} assumerà i valori di \func{lseek}.}
+\end{funcproto}
+
+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.
+
+% TODO: mettere prototipi espliciti fseeko e ftello o menzione?
+
\subsection{Input/output binario}
lettura dei dati da un buffer verso un file e viceversa. In generale questa è
la modalità che si usa quando si ha a che fare con dati non formattati. Le due
funzioni che si usano per l'I/O binario sono \funcd{fread} ed \funcd{fwrite};
-i loro prototipi sono:
+i rispettivi prototipi sono:
\begin{funcproto}{
\fhead{stdio.h}
elemento.
In realtà quello che conta nel trasferimento dei dati sono le dimensioni
-totali, che sono sempre pari al prodotto \code{size * nelem}; la sola
-differenza è che le funzioni non ritornano il numero di byte scritti,
-ma il numero di elementi.
+totali, che sono sempre pari al prodotto \code{size * nelem}, la differenza
+sta nel fatto che le funzioni non ritornano il numero di byte scritti, ma il
+numero di elementi (e con questo possono facilitare i conti).
La funzione \func{fread} legge sempre un numero intero di elementi, se
incontra la fine del file l'oggetto letto parzialmente viene scartato (lo
La seconda modalità di input/output è quella a caratteri, in cui si
trasferisce un carattere alla volta. Le funzioni per la lettura a
-caratteri sono tre, \funcd{fgetc}, \funcd{getc} e \funcd{getchar}, i
+caratteri sono tre, \funcd{fgetc}, \funcd{getc} e \funcd{getchar}, ed i
rispettivi prototipi sono:
\begin{funcproto}{
\func{fgetwc} è assicurata essere sempre una funzione. Infine \func{getwchar}
è equivalente a \code{getwc(stdin)}.
-
Per scrivere un carattere si possono usare tre funzioni, analoghe alle
precedenti usate per leggere: \funcd{putc}, \funcd{fputc} e \funcd{putchar}; i
loro prototipi sono:
questo è quello che fa la \acr{glibc}, che richiede che avvenga un'altra
operazione fra due \func{ungetc} successive.
-Non è necessario che il carattere che si manda indietro sia l'ultimo che
-si è letto, e non è necessario neanche avere letto nessun carattere
-prima di usare \func{ungetc}, ma di norma la funzione è intesa per
-essere usata per rimandare indietro l'ultimo carattere letto.
-
-Nel caso \param{c} sia un \val{EOF} la funzione non fa nulla, e
-restituisce sempre \val{EOF}; così si può usare \func{ungetc} anche
-con il risultato di una lettura alla fine del file.
+Non è necessario che il carattere che si manda indietro sia l'ultimo che si è
+letto, e non è necessario neanche avere letto nessun carattere prima di usare
+\func{ungetc}, ma di norma la funzione è intesa per essere usata per rimandare
+indietro l'ultimo carattere letto. Nel caso \param{c} sia un \val{EOF} la
+funzione non fa nulla, e restituisce sempre \val{EOF}; così si può usare
+\func{ungetc} anche con il risultato di una lettura alla fine del file.
-Se si è alla fine del file si può comunque rimandare indietro un
-carattere, il flag di end-of-file verrà automaticamente cancellato
-perché c'è un nuovo carattere disponibile che potrà essere riletto
-successivamente.
+Se si è alla fine del file si può comunque rimandare indietro un carattere, il
+flag di \textit{end-of-file} verrà automaticamente cancellato perché c'è un
+nuovo carattere disponibile che potrà essere riletto successivamente.
-Infine si tenga presente che \func{ungetc} non altera il contenuto del
-file, ma opera esclusivamente sul buffer interno. Se si esegue una
-qualunque delle operazioni di riposizionamento (vedi
-sez.~\ref{sec:file_fseek}) i caratteri rimandati indietro vengono
-scartati.
+Infine si tenga presente che \func{ungetc} non altera il contenuto del file,
+ma opera esclusivamente sul buffer interno. Se si esegue una qualunque delle
+operazioni di riposizionamento (vedi sez.~\ref{sec:file_io}) i caratteri
+rimandati indietro vengono scartati.
\subsection{Input/output di linea}
\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
+in cui si legge o si scrive una riga alla volta. Questa è la modalità usata
+normalmente per l'I/O da terminale, ed è anche quella che presenta le
caratteristiche più controverse.
Le funzioni previste dallo standard ANSI C per leggere una linea sono
{Le funzioni ritornano l'indirizzo della stringa con la linea di testo letta o
scritta in caso di successo e \val{NULL} per un errore.}
\end{funcproto}
-
-Entrambe le funzioni effettuano la lettura (dal file specificato \func{fgets},
-dallo \itindex{standard~input} \textit{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}.}
+
+Entrambe le funzioni effettuano la lettura, dal file specificato \func{fgets},
+dallo \itindex{standard~input} \textit{standard input} \func{gets}, di una
+linea di caratteri terminata dal carattere ASCII di \textit{newline}, che come
+detto corrisponde a quello generato dalla pressione del tasto di invio sulla
+tastiera. Si tratta del carattere che indica la terminazione di una riga (in
+sostanza del carattere di ``\textsl{a capo}'') che viene rappresentato nelle
+stringhe di formattazione che vedremo in sez.~\ref{sec:file_formatted_io} come
+``\verb|\n|''. Nell'esecuzione delle funzioni \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
+puntatore \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).
+far ripartire l'esecuzione nel codice inviato nella stringa stessa, che in
+genere contiene uno \textit{shell code}, cioè una sezione di programma che
+lancia una shell da cui si potranno poi eseguire altri programmi.
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
+prende in ingresso 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
+caratteri (\textit{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
La funzione \func{puts} scrive una linea di testo mantenuta
all'indirizzo \param{string} sullo \itindex{standard~output} \textit{standard
output} mentre \func{puts} la scrive sul file indicato da \param{stream}.
-
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 \itindex{standard~output} 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.
+messaggi sullo \itindex{standard~output} 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
+\textit{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
La funzione \func{fgetws} legge un massimo di \param{n} caratteri estesi dal
file \param{stream} al buffer \param{ws}, mentre la funzione \func{fputws}
-scrive la linea \param{ws} di caratteri estesi sul file \param{stream}. 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.
+scrive la linea \param{ws} di caratteri estesi sul file indicato
+da \param{stream}. 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, \textit{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
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.
+\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 \textit{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
\headfile{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 è:
+linea terminata da un \textit{newline}, esattamente allo stesso modo di
+\func{fgets}, il suo prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
indicato da \param{buffer} riallocandolo se necessario (l'indirizzo del buffer
e la sua dimensione vengono sempre riscritte). Permette così 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.
+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ò cioè passare come argomento primo
+argomento 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
+dimensione ed il nuovo puntatore vengono restituiti indietro, si noti infatti
+come entrambi gli argomenti siano dei \itindex{value~result~argument}
+\textit{value result argument}, per i quali vengono passati dei puntatori
+anziché i valori delle variabili, secondo quanto abbiamo descritto in
sez.~\ref{sec:proc_var_passing}).
Se si passa alla funzione l'indirizzo di un puntatore impostato a \val{NULL} e
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 \textit{stream} (quindi compreso il newline, ma non lo zero di
-terminazione); questo permette anche di distinguere eventuali zeri letti
-dallo \textit{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 è:
+e per evitare \itindex{memory~leak} \textit{memory leak} occorre ricordarsi di
+liberare la memoria allocata dalla funzione eseguendo una \func{free} su
+\var{ptr}.
+
+Il valore di ritorno di \func{getline} indica il numero di caratteri letti
+dallo \textit{stream}, quindi compreso il \textit{newline}, ma non lo zero di
+terminazione). Questo permette anche di distinguere anche gli eventuali zeri
+letti come dati dallo \textit{stream} da quello inserito dalla funzione dopo
+il \textit{newline} per terminare la stringa. Se si è alla fine del file e
+non si è potuto leggere nulla o se c'è stato un errore la funzione restituisce
+$-1$.
+
+La seconda estensione GNU per la lettura con l'I/O di linea è una
+generalizzazione di \func{getline} per poter usare come separatore delle linee
+un carattere qualsiasi al posto del \textit{newline}. La funzione si chiama
+\funcd{getdelim} ed il suo prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
\end{funcproto}
La funzione è identica a \func{getline} solo che usa \param{delim} al posto
-del carattere di newline come separatore di linea. 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}).
+del carattere di \textit{newline} come separatore di linea. Il comportamento
+di \func{getdelim} è identico a quello di \func{getline}, che può essere
+implementata da \func{getdelim} passando ``\verb|\n|'' come valore
+dell'argomento
+\param{delim}.
-\subsection{L'input/output formattato}
+\subsection{Input/output formattato}
\label{sec:file_formatted_io}
L'ultima modalità di input/output è quella formattata, che è una delle
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
+\textit{buffer overflow}. Per questo motivo si consiglia l'uso
dell'alternativa \funcd{snprintf}, il cui prototipo è:
\begin{funcproto}{
\func{sprintf}.}
\end{funcproto}
-La funzione è identica a \func{sprintf}, ma non scrive su \param{str} più di
-\param{size} caratteri. 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{funzioni!variadic} \textit{variadic}, prendendo un numero di argomenti
-variabile che dipende appunto da quello che si è specificato
-in \param{format}).
+\noindent la funzione è identica a \func{sprintf}, ma non scrive
+su \param{str} più di \param{size} caratteri, garantendo così che il buffer
+non possa essere sovrascritto.
-\begin{table}[htb]
+\begin{table}[!htb]
\centering
\footnotesize
\begin{tabular}[c]{|l|l|p{10cm}|}
\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{\%i} &\ctyp{int} & Identico a \cmd{\%d} 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{\%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 \%.\\
+ \cmd{\%\%}& & Stampa un ``\texttt{\%}''.\\
\hline
\end{tabular}
\caption{Valori possibili per gli specificatori di conversione in una
\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.
+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{funzioni!variadic}
+\textit{variadic}, prendendo un numero di argomenti variabile che dipende
+appunto da quello che si è specificato in \param{format}.
+
+La stringa di formato è 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.
+
+Il formato di una direttiva di conversione prevede una serie di possibili
+elementi opzionali oltre al carattere ``\cmd{\%}'' e allo specificatore di
+conversione. In generale essa è sempre del tipo:
+\begin{Example}
+% [n. parametro $] [flag] [[larghezza] [. precisione]] [tipo] conversione
+\end{Example}
+in cui tutti i valori tranne il ``\texttt{\%}'' 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 carattere
+ ``\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*}
\begin{table}[htb]
\centering
\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}.
+Dettagli ulteriori sulle varie opzioni di stampa e su tutte le casistiche
+dettagliate dei vari formati possono essere trovati nella pagina di manuale di
+\func{printf} e nella documentazione delle \acr{glibc}.
\begin{table}[htb]
\centering
Le funzioni eseguono una scansione della rispettiva fonte di input cercando
una corrispondenza di quanto letto con il formato dei dati specificato
-da \param{format}, ed effettua le relative conversione memorizzando il
+da \param{format}, ed effettua le relative conversioni memorizzando il
risultato negli argomenti seguenti, il cui numero è variabile e dipende dal
valore di \param{format}. Come per le analoghe funzioni di scrittura esistono
le relative \funcm{vscanf}, \funcm{vfscanf} e \funcm{vsscanf} che usano un
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
+ \cite{flex}.} per generare un analizzatore lessicale o
\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 \textit{stream}}
-\label{sec:file_fseek}
-
-Come per i file descriptor anche per gli \textit{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 \textit{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
-\textit{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
-\textit{stream} sono \funcd{fseek} e \funcd{rewind} i cui prototipi sono:
-
-\begin{funcproto}{
-\fhead{stdio.h}
-\fdecl{int fseek(FILE *stream, long offset, int whence)}
-\fdesc{Sposta la posizione nello \textit{stream}.}
-\fdecl{void rewind(FILE *stream)}
-\fdesc{Riporta la posizione nello \textit{stream} all'inizio del file.}
-}
-
-{La funzione \func{fseek} ritorna $0$ in caso di successo e $-1$ per un
- errore, nel qual caso \var{errno} assumerà i valori di \func{lseek},
- \func{rewind} non ritorna nulla e non ha condizioni di errore.}
-\end{funcproto}
-
-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 \textit{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{funcproto}{
-\fhead{stdio.h}
-\fdecl{long ftell(FILE *stream)}
-\fdesc{Legge la posizione attuale nello \textit{stream}.}
-}
-
-{La funzione ritorna la posizione corrente in caso di successo e $-1$ per un
- errore, nel qual caso \var{errno} assumerà i valori di \func{lseek}.}
-\end{funcproto}
-
-
-La funzione restituisce la posizione come numero di byte dall'inizio dello
-\textit{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{funcproto}{
-\fhead{stdio.h}
-\fdecl{int fsetpos(FILE *stream, fpos\_t *pos)}
-\fdesc{.}
-\fdecl{int fgetpos(FILE *stream, fpos\_t *pos)}
-\fdesc{.}
-}
-
-{La funzione ritorna $0$ in caso di successo e $-1$ per un errore, nel qual
- caso \var{errno} assumerà i valori di \func{lseek}.}
-\end{funcproto}
-
-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.
-
-% TODO: mettere prototipi espliciti fseeko e ftello o menzione?
-
\section{Funzioni avanzate}
\label{sec:file_stream_adv_func}
In questa sezione esamineremo alcune funzioni avanzate che permettono di
-eseguire operazioni particolari sugli \textit{stream}, come leggerne gli
-attributi, controllarne le modalità di bufferizzazione, gestire direttamente i
-lock impliciti per la programmazione \itindex{thread} \textit{multi-thread}.
+eseguire operazioni di basso livello nella gestione degli \textit{stream},
+come leggerne gli attributi, controllarne le modalità di bufferizzazione,
+gestire in maniera esplicita i lock impliciti presenti ad uso della
+programmazione \itindex{thread} \textit{multi-thread}.
\subsection{Le funzioni di controllo}
Al contrario di quanto avviene con i file descriptor, le librerie standard del
C non prevedono nessuna funzione come la \func{fcntl} per il controllo degli
attributi dei file. Però, dato che ogni \textit{stream} si appoggia ad un file
-descriptor, si può usare la funzione \funcd{fileno} per ottenere quest'ultimo,
-il prototipo della funzione è:
+descriptor, si può usare la funzione \funcd{fileno} per ottenere il valore di
+quest'ultimo; il suo prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
se \param{stream} non è valido.}
\end{funcproto}
-\noindent ed in questo modo diventa possibile usare direttamente \func{fcntl}.
-
-Questo permette di accedere agli attributi del file descriptor sottostante lo
-\textit{stream}, ma non ci dà nessuna informazione riguardo alle proprietà
-dello \textit{stream} medesimo. Le \acr{glibc} però supportano alcune
-estensioni derivate da Solaris, che permettono di ottenere informazioni utili.
+In questo modo diventa possibile usare direttamente \func{fcntl} sul file
+descriptor sottostante, ma anche se questo permette di accedere agli attributi
+del file descriptor sottostante lo \textit{stream}, non ci dà nessuna
+informazione riguardo alle proprietà dello \textit{stream} medesimo. Le
+\acr{glibc} però supportano alcune estensioni derivate da Solaris, che
+permettono di ottenere informazioni utili relative allo \textit{stream}.
Ad esempio in certi casi può essere necessario sapere se un certo
\textit{stream} è accessibile in lettura o scrittura. In genere questa
-informazione non è disponibile, e si deve ricordare come il file è stato
-aperto. La cosa può essere complessa se le operazioni vengono effettuate in
-una subroutine, che a questo punto necessiterà di informazioni aggiuntive
-rispetto al semplice puntatore allo \textit{stream}; questo può essere evitato
+informazione non è disponibile, e ci si deve ricordare come è stato aperto il
+file. La cosa può essere complessa se le operazioni vengono effettuate in una
+subroutine, che a questo punto necessiterà di informazioni aggiuntive rispetto
+al semplice puntatore allo \textit{stream}. Questo problema può essere risolto
con le due funzioni \funcd{\_\_freadable} e \funcd{\_\_fwritable} i cui
prototipi sono:
Però una volta che si sia aperto lo \textit{stream} (ma prima di aver compiuto
operazioni su di esso) è possibile intervenire sulle modalità di buffering; la
funzione che permette di controllare la bufferizzazione è \funcd{setvbuf}, il
-suo prototipo è:
+cui prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
un errore, nel qual caso \var{errno} assumerà un valore appropriato.}
\end{funcproto}
-
La funzione imposta la bufferizzazione dello \textit{stream} \param{stream}
-nella modalità indicata da \param{mode}, usando \param{buf} come buffer di
+nella modalità indicata da \param{mode} con uno dei valori di
+tab.~\ref{tab:file_stream_buf_mode}, usando \param{buf} come buffer di
lunghezza \param{size} e permette di controllare tutti gli aspetti della
-bufferizzazione; l'utente può specificare un buffer da usare al posto di
+bufferizzazione. L'utente può specificare un buffer da usare al posto di
quello allocato dal sistema passandone alla funzione l'indirizzo
in \param{buf} e la dimensione in \param{size}.
-Ovviamente se si usa un buffer specificato dall'utente questo deve essere
-stato allocato e rimanere disponibile per tutto il tempo in cui si opera sullo
-\textit{stream}. In genere conviene allocarlo con \func{malloc} e disallocarlo
-dopo la chiusura del file; ma fintanto che il file è usato all'interno di una
-funzione, può anche essere usata una \index{variabili!automatiche} variabile
-automatica. In \headfile{stdio.h} è definita la macro \const{BUFSIZ}, che
-indica le dimensioni generiche del buffer di uno \textit{stream}; queste
-vengono usate dalla funzione \func{setbuf}. Non è detto però che tale
-dimensione corrisponda sempre al valore ottimale (che può variare a seconda
-del dispositivo).
-
-Dato che la procedura di allocazione manuale è macchinosa, comporta dei rischi
-(come delle scritture accidentali sul buffer) e non assicura la scelta delle
-dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle funzioni
-di libreria, che sono in grado di farlo in maniera ottimale e trasparente
-all'utente (in quanto la deallocazione avviene automaticamente). Inoltre
-siccome alcune implementazioni usano parte del buffer per mantenere delle
-informazioni di controllo, non è detto che le dimensioni dello stesso
-coincidano con quelle su cui viene effettuato l'I/O.
-
\begin{table}[htb]
\centering
\footnotesize
\label{tab:file_stream_buf_mode}
\end{table}
+Ovviamente se si usa un buffer specificato dall'utente questo deve essere
+stato allocato e rimanere disponibile per tutto il tempo in cui si opera sullo
+\textit{stream}. In genere conviene allocarlo con \func{malloc} e disallocarlo
+dopo la chiusura del file; ma fintanto che il file è usato all'interno di una
+funzione, può anche essere usata una \index{variabili!automatiche} variabile
+automatica. In \headfile{stdio.h} è definita la macro \const{BUFSIZ}, che
+indica le dimensioni generiche del buffer di uno \textit{stream}, queste
+vengono usate dalla funzione \func{setbuf}. Non è detto però che tale
+dimensione corrisponda sempre al valore ottimale (che può variare a seconda
+del dispositivo).
+
+Dato che la procedura di allocazione manuale è macchinosa, comporta dei
+rischi, come delle scritture accidentali sul buffer, e non assicura la scelta
+delle dimensioni ottimali, è sempre meglio lasciare allocare il buffer alle
+funzioni di libreria, che sono in grado di farlo in maniera ottimale e
+trasparente all'utente (in quanto la deallocazione avviene
+automaticamente). Inoltre siccome alcune implementazioni usano parte del
+buffer per mantenere delle informazioni di controllo, non è detto che le
+dimensioni dello stesso coincidano con quelle su cui viene effettuato l'I/O.
+
Per evitare che \func{setvbuf} imposti il buffer basta passare un valore
\val{NULL} per \param{buf} e la funzione ignorerà l'argomento \param{size}
usando il buffer allocato automaticamente dal sistema. Si potrà comunque
Oltre a \func{setvbuf} le \acr{glibc} definiscono altre tre funzioni per la
gestione della bufferizzazione di uno \textit{stream}: \funcd{setbuf},
-\funcd{setbuffer} e \funcd{setlinebuf}; i loro prototipi sono:
+\funcd{setbuffer} e \funcd{setlinebuf}, i rispettivi prototipi sono:
\begin{funcproto}{
\fhead{stdio.h}
usa \param{buf} come buffer di dimensione \param{size} in modalità
\textit{fully buffered}. Tutte queste funzioni sono realizzate con opportune
chiamate a \func{setvbuf} e sono definite solo per compatibilità con le
-vecchie librerie BSD.
+vecchie librerie BSD, pertanto non è il caso di usarle se non per la
+portabilità su vecchi sistemi.
-Infine le \acr{glibc} provvedono le funzioni non standard\footnote{anche
- queste funzioni sono originarie di Solaris.} \funcd{\_\_flbf} e
-\funcd{\_\_fbufsize} che permettono di leggere le proprietà di bufferizzazione
-di uno \textit{stream}; i cui prototipi sono:
+Infine le \acr{glibc} provvedono le funzioni non standard, anche queste
+originarie di Solaris, \funcd{\_\_flbf} e \funcd{\_\_fbufsize} che permettono
+di leggere le proprietà di bufferizzazione di uno \textit{stream}; i cui
+prototipi sono:
\begin{funcproto}{
\fhead{stdio\_ext.h}
Come già accennato, indipendentemente dalla modalità di bufferizzazione
scelta, si può forzare lo scarico dei dati sul file con la funzione
-\funcd{fflush}, il suo prototipo è:
+\funcd{fflush}, il cui prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
\func{write}.}
\end{funcproto}
-\noindent anche di questa funzione esiste una analoga
-\func{fflush\_unlocked}\footnote{accessibile definendo \macro{\_BSD\_SOURCE} o
- \macro{\_SVID\_SOURCE} o \macro{\_GNU\_SOURCE}.} che non effettua il blocco
-dello stream.
+\noindent anche di questa funzione esiste una analoga \func{fflush\_unlocked}
+(accessibile definendo \macro{\_BSD\_SOURCE} o \macro{\_SVID\_SOURCE} o
+\macro{\_GNU\_SOURCE}) che non effettua il blocco dello stream.
% TODO aggiungere prototipo \func{fflush\_unlocked}?
\textit{stream} aperti. Esistono però circostanze, ad esempio quando si vuole
essere sicuri che sia stato eseguito tutto l'output su terminale, in cui serve
poter effettuare lo scarico dei dati solo per gli \textit{stream} in modalità
-line buffered; per questo motivo le \acr{glibc} supportano una estensione di
+line buffered. Per fare questo le \acr{glibc} supportano una estensione di
Solaris, la funzione \funcd{\_flushlbf}, il cui prototipo è:
\begin{funcproto}{
Lo standard POSIX richiede che le operazioni sui file siano atomiche rispetto
ai \textit{thread}, per questo le operazioni sui buffer effettuate dalle
funzioni di libreria durante la lettura e la scrittura di uno \textit{stream}
-devono essere opportunamente protette (in quanto il sistema assicura
-l'atomicità solo per le \textit{system call}). Questo viene fatto associando
-ad ogni \textit{stream} un opportuno blocco che deve essere implicitamente
+devono essere opportunamente protette, in quanto il sistema assicura
+l'atomicità solo per le \textit{system call}. Questo viene fatto associando ad
+ogni \textit{stream} un opportuno blocco che deve essere implicitamente
acquisito prima dell'esecuzione di qualunque operazione.
Ci sono comunque situazioni in cui questo non basta, come quando un
\textit{thread} necessita di compiere più di una operazione sullo
-\textit{stream} atomicamente, per questo motivo le librerie provvedono anche
-delle funzioni \funcd{flockfile} e \funcd{funlockfile}, che permettono la
-gestione esplicita dei blocchi sugli \textit{stream}; esse sono disponibili
-definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
+\textit{stream} atomicamente. Per questo motivo le librerie provvedono anche
+le funzioni \funcd{flockfile} e \funcd{funlockfile} che permettono la gestione
+esplicita dei blocchi sugli \textit{stream}. Esse sono disponibili definendo
+\macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono:
\begin{funcproto}{
\fhead{stdio.h}
\end{funcproto}
La funzione \func{flockfile} esegue l'acquisizione del lock dello
-\textit{stream} \param{stream}, bloccandosi se il lock non è disponibile,
-mentre \func{funlockfile} rilascia il lock.
+\textit{stream} \param{stream}, bloccandosi se questo risulta non è
+disponibile, mentre \func{funlockfile} rilascia un lock che si è
+precedentemente acquisito.
-Si può poi provare ad acquisire un lock senza bloccarsi con
-\funcd{ftrylockfile}, il cui prototipo è:
+Una terza funzione, che serve a provare ad acquisire un lock senza bloccarsi
+qualora non sia possibile, è \funcd{ftrylockfile}, il cui prototipo è:
\begin{funcproto}{
\fhead{stdio.h}
strutture di dati coinvolte, le operazioni di blocco non sono del tutto
indolori, e quando il locking dello \textit{stream} non è necessario (come in
tutti i programmi che non usano i \textit{thread}), tutta la procedura può
-comportare dei costi pesanti in termini di prestazioni. Per questo motivo
-abbiamo visto come alle usuali funzioni di I/O non formattato siano associate
-delle versioni \code{\_unlocked} (alcune previste dallo stesso standard POSIX,
-altre aggiunte come estensioni dalle \acr{glibc}) che possono essere usate
-quando il locking non serve\footnote{in certi casi dette funzioni possono
- essere usate, visto che sono molto più efficienti, anche in caso di
- necessità di locking, una volta che questo sia stato acquisito manualmente.}
-con prestazioni molto più elevate, dato che spesso queste versioni (come
-accade per \func{getc} e \func{putc}) sono realizzate come macro.
+comportare dei costi pesanti in termini di prestazioni.
+
+Per questo motivo abbiamo visto come alle usuali funzioni di I/O non
+formattato siano associate delle versioni \code{\_unlocked} (alcune previste
+dallo stesso standard POSIX, altre aggiunte come estensioni dalle \acr{glibc})
+che possono essere usate quando il locking non serve\footnote{in certi casi
+ dette funzioni possono essere usate, visto che sono molto più efficienti,
+ anche in caso di necessità di locking, una volta che questo sia stato
+ acquisito manualmente.} con prestazioni molto più elevate, dato che spesso
+queste versioni (come accade per \func{getc} e \func{putc}) sono realizzate
+come macro.
La sostituzione di tutte le funzioni di I/O con le relative versioni
\code{\_unlocked} in un programma che non usa i \textit{thread} è però un
-lavoro abbastanza noioso; per questo motivo le \acr{glibc} forniscono al
-programmatore pigro un'altra via\footnote{anche questa mutuata da estensioni
- introdotte in Solaris.} da poter utilizzare per disabilitare in blocco il
+lavoro abbastanza noioso. Per questo motivo le \acr{glibc} forniscono al
+programmatore pigro un'altra via, anche questa mutuata da estensioni
+introdotte in Solaris, da poter utilizzare per disabilitare in blocco il
locking degli \textit{stream}: l'uso della funzione \funcd{\_\_fsetlocking},
il cui prototipo è:
\begin{funcproto}{
\fhead{stdio\_ext.h}
-\fdecl{int \_\_fsetlocking (FILE *stream, int type)}
+\fdecl{int \_\_fsetlocking(FILE *stream, int type)}
\fdesc{Specifica se abilitare il locking su uno \textit{stream}.}
}
La funzione imposta o legge lo stato della modalità in cui le operazioni di
I/O su \param{stream} vengono effettuate rispetto all'acquisizione implicita
-del locking a seconda del valore specificato con \param{type}, che può essere
-uno dei seguenti:
-\begin{basedescript}{\desclabelwidth{4.0cm}}
-\item[\const{FSETLOCKING\_INTERNAL}] Lo \textit{stream} userà da ora in poi il
- blocco implicito predefinito.
-\item[\const{FSETLOCKING\_BYCALLER}] Al ritorno della funzione sarà l'utente a
- dover gestire da solo il locking dello \textit{stream}.
-\item[\const{FSETLOCKING\_QUERY}] Restituisce lo stato corrente della modalità
- di blocco dello \textit{stream}.
-\end{basedescript}
+del locking a seconda del valore specificato con \param{type}, che può
+assumere uno dei valori indicati in tab.~\ref{tab:file_fsetlocking_type}.
+
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|p{8cm}|}
+ \hline
+ \textbf{Valore} & \textbf{Significato} \\
+ \hline
+ \hline
+ \const{FSETLOCKING\_INTERNAL}& Lo \textit{stream} userà da ora in poi il
+ blocco implicito predefinito.\\
+ \const{FSETLOCKING\_BYCALLER}& Al ritorno della funzione sarà l'utente a
+ dover gestire da solo il locking dello
+ \textit{stream}.\\
+ \const{FSETLOCKING\_QUERY} & Restituisce lo stato corrente della
+ modalità di blocco dello
+ \textit{stream}.\\
+ \hline
+ \end{tabular}
+ \caption{Valori dell'argomento \param{type} di \func{\_\_fsetlocking}
+ per l'impostazione delle modalità di bufferizzazione.}
+ \label{tab:file_fsetlocking_type}
+\end{table}
La funzione, se usata con \const{FSETLOCKING\_QUERY}, non modifica la modalità
di operazione ma restituisce lo stato di locking interno dello \textit{stream}
con uno dei valori \const{FSETLOCKING\_INTERNAL} o
\const{FSETLOCKING\_BYCALLER}.
-
% TODO trattare \func{clearerr\_unlocked}
-
\itindend{thread}
% LocalWords: IONBF IOLBF IOFBF setbuffer setlinebuf flbf fbufsize flushlbf hh
% LocalWords: fsync fpurge flockfile ftrylockfile funlockfile files fig flags
% LocalWords: locking fsetlocking type virtual operation dentry unistd sys AT
-% LocalWords: modification hole functions pathname EEXIST CREAT EINTR
+% LocalWords: modification hole functions pathname EEXIST CREAT EINTR attack
% LocalWords: EISDIR EFBIG EOVERFLOW ELOOP NOFOLLOW ENODEV ENOENT ENOTDIR fork
% LocalWords: EMFILE ENAMETOOLONG ENFILE ENOMEM ENOSPC EROFS exec access RDWR
% LocalWords: RDONLY ioctl AND ACCMODE creation Denial Service DoS opendir NFS
% LocalWords: gid group FOLLOW REMOVEDIR cmd arg flock SETFD GETFD GETFL SETFL
% LocalWords: GETLK SETLK SETLKW GETOWN PID Signal SIGURG SETOWN GETSIG SETSIG
% LocalWords: sigaction SIGINFO siginfo SETLEASE lease GETLEASE NOTIFY request
-% LocalWords: everything framebuffer ENOTTY argp CDROM lsattr chattr magic
-% LocalWords: number FIOCLEX FIONCLEX FIOASYNC FIONBIO FIOSETOWN FIOGETOWN
+% LocalWords: everything framebuffer ENOTTY argp CDROM lsattr chattr magic TID
+% LocalWords: number FIOCLEX FIONCLEX FIOASYNC FIONBIO FIOSETOWN FIOGETOWN pid
% LocalWords: FIONREAD epoll FIOQSIZE side effects SAFE BYCALLER QUERY EACCES
-% LocalWords: EBUSY OpenBSD syncfs
-% LocalWords: ENXIO NONBLOCK WRONLY EPERM NOATIME ETXTBSY EWOULDBLOCK
-% LocalWords: EFAULT
+% LocalWords: EBUSY OpenBSD syncfs futimes timespec only init ESRCH kill NTPL
+% LocalWords: ENXIO NONBLOCK WRONLY EPERM NOATIME ETXTBSY EWOULDBLOCK PGRP SZ
+% LocalWords: EFAULT capabilities GETPIPE SETPIPE RESOURCE
%%% Local Variables:
%%% mode: latex
projects / gapil.git / commitdiff