From: Simone Piccardi Date: Sun, 11 Mar 2012 15:15:50 +0000 (+0000) Subject: Correzioni alle tabelle e fine revisione del quinto capitolo (sezione X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=commitdiff_plain;h=5e7576925418aee6a7fdd1eb14f2ee8b65aee305;p=gapil.git Correzioni alle tabelle e fine revisione del quinto capitolo (sezione sugli stream). --- diff --git a/filedir.tex b/filedir.tex index 656510d..cd1fa6b 100644 --- a/filedir.tex +++ b/filedir.tex @@ -1153,18 +1153,18 @@ eseguita una sincronizzazione dei dati. \textbf{Costante} & \textbf{Descrizione}\\ \hline \hline - \const{MNT\_FORCE} & forza lo smontaggio del filesystem anche se questo è + \const{MNT\_FORCE} & Forza lo smontaggio del filesystem anche se questo è occupato (presente dai kernel della serie 2.2).\\ - \const{MNT\_DETACH} & esegue uno smontaggio ``\textsl{pigro}'', in cui si + \const{MNT\_DETACH} & Esegue uno smontaggio ``\textsl{pigro}'', in cui si blocca l'accesso ma si aspetta che il filesystem si liberi (presente dal kernel 2.4.11 e dalla \acr{glibc} 2.11).\\ - \const{MNT\_EXPIRE} & se non occupato marca un \itindex{mount~point} + \const{MNT\_EXPIRE} & Se non occupato marca un \itindex{mount~point} \textit{mount point} come ``\textsl{in scadenza}'' in modo che ad una successiva chiamata senza utilizzo del filesystem questo venga smontato (presente dal kernel 2.6.8 e dalla \acr{glibc} 2.11).\\ - \const{UMOUNT\_NOFOLLOW}& non dereferenzia \param{target} se questo è un + \const{UMOUNT\_NOFOLLOW}& Non dereferenzia \param{target} se questo è un collegamento simbolico (vedi sez.~\ref{sec:link_symlink_rename}) evitando problemi di sicurezza (presente dal kernel 2.6.34).\\ @@ -3211,13 +3211,13 @@ tipo di file in maniera standardizzata. \textbf{Macro} & \textbf{Tipo del file} \\ \hline \hline - \macro{S\_ISREG}\texttt{(m)} & file normale.\\ - \macro{S\_ISDIR}\texttt{(m)} & directory.\\ - \macro{S\_ISCHR}\texttt{(m)} & dispositivo a caratteri.\\ - \macro{S\_ISBLK}\texttt{(m)} & dispositivo a blocchi.\\ - \macro{S\_ISFIFO}\texttt{(m)} & fifo.\\ - \macro{S\_ISLNK}\texttt{(m)} & collegamento simbolico.\\ - \macro{S\_ISSOCK}\texttt{(m)} & socket.\\ + \macro{S\_ISREG}\texttt{(m)} & File normale.\\ + \macro{S\_ISDIR}\texttt{(m)} & Directory.\\ + \macro{S\_ISCHR}\texttt{(m)} & Dispositivo a caratteri.\\ + \macro{S\_ISBLK}\texttt{(m)} & Dispositivo a blocchi.\\ + \macro{S\_ISFIFO}\texttt{(m)} & Fifo.\\ + \macro{S\_ISLNK}\texttt{(m)} & Collegamento simbolico.\\ + \macro{S\_ISSOCK}\texttt{(m)} & Socket.\\ \hline \end{tabular} \caption{Macro per i tipi di file (definite in \headfile{sys/stat.h}).} @@ -3250,9 +3250,11 @@ come argomento il valore di \var{st\_mode}. \const{S\_IFCHR} & 0020000 & Dispositivo a caratteri.\\ \const{S\_IFIFO} & 0010000 & Fifo.\\ \hline - \const{S\_ISUID} & 0004000 & \itindex{suid~bit} \acr{suid} bit.\\ - \const{S\_ISGID} & 0002000 & \itindex{sgid~bit} \acr{sgid} bit.\\ - \const{S\_ISVTX} & 0001000 & \itindex{sticky~bit} \acr{sticky} bit.\\ + \const{S\_ISUID} & 0004000 & Set user ID \itindex{suid~bit} (\acr{suid}) + bit.\\ + \const{S\_ISGID} & 0002000 & Set group ID \itindex{sgid~bit} + (\acr{sgid}) bit.\\ + \const{S\_ISVTX} & 0001000 & \itindex{sticky~bit} \acr{Sticky} bit.\\ \hline \const{S\_IRWXU} & 00700 & Maschera per i permessi del proprietario.\\ \const{S\_IRUSR} & 00400 & Il proprietario ha permesso di lettura.\\ @@ -4387,9 +4389,9 @@ file. \textbf{\param{mode}} & \textbf{Valore} & \textbf{Significato} \\ \hline \hline - \const{S\_ISUID} & 04000 & Set user ID \itindex{suid~bit}.\\ - \const{S\_ISGID} & 02000 & Set group ID \itindex{sgid~bit}.\\ - \const{S\_ISVTX} & 01000 & Sticky bit \itindex{sticky~bit}.\\ + \const{S\_ISUID} & 04000 & Set user ID \itindex{suid~bit} bit.\\ + \const{S\_ISGID} & 02000 & Set group ID \itindex{sgid~bit} bit.\\ + \const{S\_ISVTX} & 01000 & Sticky \itindex{sticky~bit} bit.\\ \hline \const{S\_IRWXU} & 00700 & L'utente ha tutti i permessi.\\ \const{S\_IRUSR} & 00400 & L'utente ha il permesso di lettura.\\ @@ -5201,21 +5203,21 @@ la capacità \itindex{capabilities} \const{CAP\_FOWNER}. \textbf{Tipo} & \textbf{Descrizione} \\ \hline \hline - \const{ACL\_USER\_OBJ} & voce che contiene i diritti di accesso del + \const{ACL\_USER\_OBJ} & Voce che contiene i diritti di accesso del proprietario del file.\\ - \const{ACL\_USER} & voce che contiene i diritti di accesso per + \const{ACL\_USER} & Voce che contiene i diritti di accesso per l'utente indicato dal rispettivo qualificatore.\\ - \const{ACL\_GROUP\_OBJ}& voce che contiene i diritti di accesso del + \const{ACL\_GROUP\_OBJ}& Voce che contiene i diritti di accesso del gruppo proprietario del file.\\ - \const{ACL\_GROUP} & voce che contiene i diritti di accesso per + \const{ACL\_GROUP} & Voce che contiene i diritti di accesso per il gruppo indicato dal rispettivo qualificatore.\\ - \const{ACL\_MASK} & voce che contiene la maschera dei massimi + \const{ACL\_MASK} & Voce che contiene la maschera dei massimi permessi di accesso che possono essere garantiti da voci del tipo \const{ACL\_USER}, \const{ACL\_GROUP} e \const{ACL\_GROUP\_OBJ}.\\ - \const{ACL\_OTHER} & voce che contiene i diritti di accesso di chi + \const{ACL\_OTHER} & Voce che contiene i diritti di accesso di chi non corrisponde a nessuna altra voce dell'ACL.\\ \hline \end{tabular} @@ -5692,23 +5694,23 @@ tab.~\ref{tab:acl_to_text_options}. \textbf{Tipo} & \textbf{Descrizione} \\ \hline \hline - \const{TEXT\_ABBREVIATE} & stampa le voci in forma abbreviata.\\ + \const{TEXT\_ABBREVIATE} & Stampa le voci in forma abbreviata.\\ \const{TEXT\_NUMERIC\_IDS} & non effettua la risoluzione numerica di \ids{UID} e \ids{GID}.\\ - \const{TEXT\_SOME\_EFFECTIVE}& per ciascuna voce che contiene permessi che + \const{TEXT\_SOME\_EFFECTIVE}& Per ciascuna voce che contiene permessi che vengono eliminati dalla \const{ACL\_MASK} viene generato un commento con i permessi effettivamente risultanti; il commento è separato con un tabulatore.\\ - \const{TEXT\_ALL\_EFFECTIVE} & viene generato un commento con i permessi + \const{TEXT\_ALL\_EFFECTIVE} & Viene generato un commento con i permessi effettivi per ciascuna voce che contiene permessi citati nella \const{ACL\_MASK}, anche quando questi non vengono modificati da essa; il commento è separato con un tabulatore.\\ - \const{TEXT\_SMART\_INDENT} & da usare in combinazione con le precedenti - \const{TEXT\_SOME\_EFFECTIVE} e - \const{TEXT\_ALL\_EFFECTIVE} aumenta + \const{TEXT\_SMART\_INDENT} & Da usare in combinazione con le precedenti + opzioni \const{TEXT\_SOME\_EFFECTIVE} e + \const{TEXT\_ALL\_EFFECTIVE}, aumenta automaticamente il numero di spaziatori prima degli eventuali commenti in modo da mantenerli allineati.\\ @@ -5755,9 +5757,10 @@ buffer di dimensione sufficiente, il suo prototipo è: } \end{funcproto} -Ottenuta con \func{acl\_size} la dimensione per il buffer lo si potrà allocare -direttamente con \func{malloc}. La rappresentazione binaria di una ACL si -potrà poi ottenere con la funzione \funcd{acl\_copy\_ext}, il cui prototipo è: +Ottenuta con \func{acl\_size} la dimensione per il buffer di una ACL lo si +potrà allocare direttamente con \func{malloc}. La rappresentazione binaria di +una ACL si potrà invece ottenere con la funzione \funcd{acl\_copy\_ext}, il +cui prototipo è: \begin{funcproto}{ \fhead{sys/types.h} @@ -6271,11 +6274,11 @@ identificate tramite le costanti di tab.~\ref{tab:quotactl_id_format}. \textbf{Identificatore} & \textbf{Descrizione} \\ \hline \hline - \const{QFMT\_VFS\_OLD}& il vecchio (ed obsoleto) formato delle quote.\\ - \const{QFMT\_VFS\_V0} & la versione 0 usata dal VFS di Linux, supporta + \const{QFMT\_VFS\_OLD}& Il vecchio (ed obsoleto) formato delle quote.\\ + \const{QFMT\_VFS\_V0} & La versione 0 usata dal VFS di Linux, supporta \ids{UID} e \ids{GID} a 32 bit e limiti fino a $2^{42}$ byte e $2^{32}$ file.\\ - \const{QFMT\_VFS\_V1} & la versione 1 usata dal VFS di Linux, supporta + \const{QFMT\_VFS\_V1} & La versione 1 usata dal VFS di Linux, supporta \ids{UID} e \ids{GID} a 32 bit e limiti fino a $2^{64}$ byte e $2^{64}$ file.\\ \hline diff --git a/fileio.tex b/fileio.tex index 9eacc55..6c0a30e 100644 --- a/fileio.tex +++ b/fileio.tex @@ -1582,7 +1582,7 @@ relativo ad una directory specificata.\footnote{l'introduzione è avvenuta su 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}. @@ -1770,7 +1770,7 @@ invece di quello reale (il comportamento di default, che riprende quello di 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}{ @@ -1826,16 +1826,16 @@ costanti utilizzabili per i valori di \param{flags}. \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 @@ -1971,7 +1971,7 @@ il nome indicato nel precedente prototipo), è riportata di seguito: \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 @@ -2007,7 +2007,7 @@ il nome indicato nel precedente prototipo), è riportata di seguito: 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 @@ -2062,7 +2062,7 @@ il nome indicato nel precedente prototipo), è riportata di seguito: \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 @@ -2101,11 +2101,11 @@ il nome indicato nel precedente prototipo), è riportata di seguito: 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 @@ -2159,7 +2159,7 @@ il nome indicato nel precedente prototipo), è riportata di seguito: \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}.} @@ -2196,7 +2196,7 @@ il nome indicato nel precedente prototipo), è riportata di seguito: 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 @@ -2270,7 +2270,7 @@ per compiere operazioni specializzate; il suo prototipo è: 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 @@ -2402,7 +2402,7 @@ ANSI C, che invece sono realizzate attraverso opportune funzioni di libreria, 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 @@ -2436,23 +2436,22 @@ operazioni di lettura e scrittura in blocchi di dimensioni appropriate 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 @@ -2461,10 +2460,10 @@ indicatori di stato e di fine del file. 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 @@ -2510,35 +2509,34 @@ file. 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} @@ -2551,8 +2549,8 @@ modalità \textit{fully buffered}. 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. @@ -2566,22 +2564,19 @@ più opportuna a seconda del file o del dispositivo scelto. 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. @@ -2591,7 +2586,7 @@ 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} @@ -2612,18 +2607,17 @@ Le funzioni che si possono usare per aprire uno \textit{stream} sono solo tre: \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 @@ -2683,10 +2677,9 @@ compatibilità, ma non ha alcun effetto. 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 @@ -2699,15 +2692,18 @@ essere compatibili con quelli con cui il file descriptor è stato aperto. 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 @@ -2724,12 +2720,8 @@ usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche 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} @@ -2767,51 +2759,61 @@ GNU implementata dalle \acr{glibc}, accessibile avendo definito 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}, @@ -2832,10 +2834,10 @@ GNU implementata dalle \acr{glibc}, accessibile avendo definito 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 è: @@ -2850,11 +2852,111 @@ 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} @@ -2865,7 +2967,7 @@ interfaccia dei file descriptor, e provvede semplicemente la scrittura e la 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} @@ -2897,9 +2999,9 @@ in cui si specifica la dimensione dell'intera struttura ed un solo 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 @@ -2963,7 +3065,7 @@ sez.~\ref{sec:file_stream_thread} per i dettagli), i loro prototipi sono: 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}{ @@ -3031,7 +3133,6 @@ restituisce come intero, ed in genere è implementata come una macro, mentre \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: @@ -3115,33 +3216,29 @@ di caratteri, alle implementazioni è richiesto di garantire solo un livello; 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 @@ -3160,38 +3257,44 @@ prototipi 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 @@ -3214,14 +3317,13 @@ rispettivi prototipi sono: 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 @@ -3244,11 +3346,11 @@ loro prototipi sono: 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 @@ -3260,23 +3362,22 @@ 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. +\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} @@ -3292,19 +3393,21 @@ La funzione 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). 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 @@ -3313,19 +3416,22 @@ 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 \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} @@ -3339,13 +3445,14 @@ chiama \funcd{getdelim} ed il suo prototipo è: \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 @@ -3383,7 +3490,7 @@ 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 +\textit{buffer overflow}. Per questo motivo si consiglia l'uso dell'alternativa \funcd{snprintf}, il cui prototipo è: \begin{funcproto}{ @@ -3396,16 +3503,11 @@ dell'alternativa \funcd{snprintf}, il cui prototipo è: \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}|} @@ -3415,7 +3517,7 @@ in \param{format}). \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.\\ @@ -3441,7 +3543,7 @@ in \param{format}). \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 @@ -3449,11 +3551,41 @@ in \param{format}). \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 @@ -3475,33 +3607,9 @@ tab.~\ref{tab:file_format_spec}) che la conclude. \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 @@ -3643,7 +3751,7 @@ famiglia \func{scanf}; fra queste le tre più importanti sono \funcd{scanf}, 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 @@ -3687,113 +3795,21 @@ 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 + \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} @@ -3802,8 +3818,8 @@ lock impliciti per la programmazione \itindex{thread} \textit{multi-thread}. 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} @@ -3816,19 +3832,19 @@ il prototipo della funzione è: 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: @@ -3889,7 +3905,7 @@ vengono allocati automaticamente. 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} @@ -3901,34 +3917,14 @@ suo prototipo è: 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 @@ -3947,6 +3943,26 @@ coincidano con quelle su cui viene effettuato l'I/O. \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 @@ -3957,7 +3973,7 @@ vengono sempre ignorati. 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} @@ -3979,12 +3995,13 @@ disabilita la bufferizzazione se \param{buf} è \val{NULL}, altrimenti 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} @@ -4001,7 +4018,7 @@ di uno \textit{stream}; i cui prototipi sono: 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} @@ -4015,10 +4032,9 @@ scelta, si può forzare lo scarico dei dati sul file con la funzione \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}? @@ -4026,7 +4042,7 @@ Se \param{stream} è \val{NULL} lo scarico dei dati è forzato per tutti gli \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}{ @@ -4076,17 +4092,17 @@ pesantemente dalle richieste necessarie per garantirne l'uso con i 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} @@ -4099,11 +4115,12 @@ definendo \macro{\_POSIX\_THREAD\_SAFE\_FUNCTIONS} ed i loro prototipi sono: \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} @@ -4120,27 +4137,29 @@ operazioni volute, per poi rilasciarlo. Ma, vista la complessità delle 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}.} } @@ -4150,26 +4169,39 @@ il cui prototipo è: 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} @@ -4202,7 +4234,7 @@ con uno dei valori \const{FSETLOCKING\_INTERNAL} o % 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 @@ -4219,12 +4251,12 @@ con uno dei valori \const{FSETLOCKING\_INTERNAL} o % 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 diff --git a/intro.tex b/intro.tex index 1b78616..443cd33 100644 --- a/intro.tex +++ b/intro.tex @@ -1362,7 +1362,7 @@ una opportuna macro; queste estensioni sono illustrate nel seguente elenco: presente negli standard con i file di grandi dimensioni, ed in particolare definire le due funzioni \func{fseeko} e \func{ftello} che al contrario delle corrispettive \func{fseek} e \func{ftell} usano il tipo di dato - specifico \type{off\_t} (vedi sez.~\ref{sec:file_fseek}). + specifico \type{off\_t} (vedi sez.~\ref{sec:file_io}). \item[\macro{\_LARGEFILE64\_SOURCE}] definendo questa macro si rendono disponibili le funzioni di una interfaccia alternativa al supporto di valori diff --git a/process.tex b/process.tex index 4eb8d72..c2a03af 100644 --- a/process.tex +++ b/process.tex @@ -1616,20 +1616,20 @@ tipologia di errore riscontrata. \textbf{Valore} & \textbf{Significato} \\ \hline \hline - \const{MCHECK\_OK} & riportato a \func{mprobe} se nessuna + \const{MCHECK\_OK} & Riportato a \func{mprobe} se nessuna inconsistenza è presente.\\ - \const{MCHECK\_DISABLED}& riportato a \func{mprobe} se si è chiamata + \const{MCHECK\_DISABLED}& Riportato a \func{mprobe} se si è chiamata \func{mcheck} dopo aver già usato \func{malloc}.\\ - \const{MCHECK\_HEAD} & i dati immediatamente precedenti il buffer sono + \const{MCHECK\_HEAD} & I dati immediatamente precedenti il buffer sono stati modificati, avviene in genere quando si decrementa eccessivamente il valore di un puntatore scrivendo poi prima dell'inizio del buffer.\\ - \const{MCHECK\_TAIL} & i dati immediatamente seguenti il buffer sono + \const{MCHECK\_TAIL} & I dati immediatamente seguenti il buffer sono stati modificati, succede quando si va scrivere oltre la dimensione corretta del buffer.\\ - \const{MCHECK\_FREE} & il buffer è già stato disallocato.\\ + \const{MCHECK\_FREE} & Il buffer è già stato disallocato.\\ \hline \end{tabular} \caption{Valori dello stato dell'allocazione di memoria ottenibili dalla diff --git a/prochand.tex b/prochand.tex index 280ace4..0bc5db1 100644 --- a/prochand.tex +++ b/prochand.tex @@ -3466,15 +3466,15 @@ della priorità da impostare con l'argomento \param{ioprio} di \hline \hline \macro{IOPRIO\_PRIO\_CLASS}\texttt{(\textit{value})} - & dato il valore di una priorità come + & Dato il valore di una priorità come restituito da \func{ioprio\_get} estrae il valore della classe.\\ \macro{IOPRIO\_PRIO\_DATA}\texttt{(\textit{value})} - & dato il valore di una priorità come + & Dato il valore di una priorità come restituito da \func{ioprio\_get} estrae il valore della priorità.\\ \macro{IOPRIO\_PRIO\_VALUE}\texttt{(\textit{class},\textit{prio})} - & dato un valore di priorità ed una classe + & Dato un valore di priorità ed una classe ottiene il valore numerico da passare a \func{ioprio\_set}.\\ \hline