Inserita l'indicizzazione delle funzioni. Ricontrollate le chiamate

alla macro \func{} per eliminare quelle improprie

diff --git a/elemtcp.tex b/elemtcp.tex
index f092de0e8549674655f9287c5535aa8320fa5ba6..46bffafba14e00f6bc771fb7e8b813d005250026 100644 (file)
--- a/elemtcp.tex
+++ b/elemtcp.tex
@@ -1001,7 +1001,7 @@ quello creato all'inizio e messo in ascolto con \func{listen}, e non viene
 toccato dalla funzione.  
 Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
 il processo\footnote{a meno che non si sia settato il socket per essere
 toccato dalla funzione.  
 Se non ci sono connessioni pendenti da accettare la funzione mette in attesa
 il processo\footnote{a meno che non si sia settato il socket per essere

-  non-bloccante, nel qual caso ritorna con l'errore \func{EAGAIN},
+  non-bloccante, nel qual caso ritorna con l'errore \macro{EAGAIN},

   torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
 fintanto che non ne arriva una.
  
   torneremo su questa modalità di operazione in \secref{sec:xxx_sock_noblock}}
 fintanto che non ne arriva una.
  

diff --git a/filedir.tex b/filedir.tex
index 00ea801fa27a88149109b387f762efa063bda381..b09d7609c60de190299697755e247fd2e3da6891 100644 (file)
--- a/filedir.tex
+++ b/filedir.tex
@@ -53,7 +53,7 @@ suole chiamare questo tipo di associazione un collegamento diretto (o
 \textit{hard link}).  Il prototipo della funzione e le sue caratteristiche
 principali, come risultano dalla man page, sono le seguenti:
 \begin{prototype}{unistd.h}
 \textit{hard link}).  Il prototipo della funzione e le sue caratteristiche
 principali, come risultano dalla man page, sono le seguenti:
 \begin{prototype}{unistd.h}

-{int link(const char * oldpath, const char * newpath)}
+{int link(const char *oldpath, const char *newpath)}

   Crea un nuovo collegamento diretto al file indicato da \var{oldpath}
   dandogli nome \var{newpath}.
   
   Crea un nuovo collegamento diretto al file indicato da \var{oldpath}
   dandogli nome \var{newpath}.
   


@@ -108,7 +108,7 @@ funzione restituisce l'errore \macro{EPERM}.
 La rimozione di un file (o più precisamente della voce che lo referenzia
 all'interno di una directory) si effettua con la funzione \func{unlink}; il
 suo prototipo è il seguente:
 La rimozione di un file (o più precisamente della voce che lo referenzia
 all'interno di una directory) si effettua con la funzione \func{unlink}; il
 suo prototipo è il seguente:

-\begin{prototype}{unistd.h}{int unlink(const char * pathname)}
+\begin{prototype}{unistd.h}{int unlink(const char *pathname)}

   Cancella il nome specificato dal pathname nella relativa directory e
   decrementa il numero di riferimenti nel relativo inode. Nel caso di link
   simbolico cancella il link simbolico; nel caso di socket, fifo o file di
   Cancella il nome specificato dal pathname nella relativa directory e
   decrementa il numero di riferimenti nel relativo inode. Nel caso di link
   simbolico cancella il link simbolico; nel caso di socket, fifo o file di


@@ -275,19 +275,19 @@ link simbolico comporta l'applicazione della funzione al file da esso
 specificato. La funzione che permette di creare un nuovo link simbolico è
 \func{symlink}; il suo prototipo è:
 \begin{prototype}{unistd.h}
 specificato. La funzione che permette di creare un nuovo link simbolico è
 \func{symlink}; il suo prototipo è:
 \begin{prototype}{unistd.h}

-  {int symlink(const char * oldpath, const char * newpath)} 
-  Crea un nuovo link simbolico di nome \func{newpath} il cui contenuto è
-  \func{oldpath}.
+  {int symlink(const char *oldpath, const char *newpath)} 
+  Crea un nuovo link simbolico di nome \param{newpath} il cui contenuto è
+  \param{oldpath}.

   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso la variabile \var{errno} restituisce i valori:
   \begin{errlist}
   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso la variabile \var{errno} restituisce i valori:
   \begin{errlist}

-  \item[\macro{EPERM}] il filesystem che contiene \var{newpath} non supporta i
+  \item[\macro{EPERM}] il filesystem che contiene \param{newpath} non supporta i

     link simbolici.
     link simbolici.

-  \item[\macro{ENOENT}] una componente di \var{newpath} non esiste o
-    \func{oldpath} è una stringa vuota.
-  \item[\macro{EEXIST}] esiste già un file \var{newpath}.
-  \item[\macro{EROFS}] \var{newpath} è su un filesystem montato in sola
+  \item[\macro{ENOENT}] una componente di \param{newpath} non esiste o
+    \param{oldpath} è una stringa vuota.
+  \item[\macro{EEXIST}] esiste già un file \param{newpath}.
+  \item[\macro{EROFS}] \param{newpath} è su un filesystem montato in sola

     lettura.
   \end{errlist}
   ed inoltre \macro{EFAULT}, \macro{EACCES}, \macro{ENAMETOOLONG},
     lettura.
   \end{errlist}
   ed inoltre \macro{EFAULT}, \macro{EACCES}, \macro{ENAMETOOLONG},


@@ -296,10 +296,10 @@ specificato. La funzione che permette di creare un nuovo link simbolico 
 \end{prototype}
 
 Si tenga presente che la funzione non effettua nessun controllo sull'esistenza
 \end{prototype}
 
 Si tenga presente che la funzione non effettua nessun controllo sull'esistenza

-di un file di nome \var{oldpath}, ma si limita ad inserire quella stringa nel
-link simbolico. Pertanto un link simbolico può anche riferirsi ad un file che
-non esiste: quello che viene chiamato un \textit{dangling link}, letteralmente
-\textsl{link ciondolante}.
+di un file di nome \param{oldpath}, ma si limita ad inserire quella stringa
+nel link simbolico. Pertanto un link simbolico può anche riferirsi ad un file
+che non esiste: quello che viene chiamato un \textit{dangling link},
+letteralmente \textsl{link ciondolante}.

 
 
 Come accennato i link simbolici sono risolti automaticamente dal kernel
 
 
 Come accennato i link simbolici sono risolti automaticamente dal kernel


@@ -354,7 +354,7 @@ alle informazioni del link invece che a quelle del file a cui esso fa
 riferimento. Quando si vuole leggere il contenuto di un link simbolico si usa
 la funzione \func{readlink}, il cui prototipo è:
 \begin{prototype}{unistd.h}
 riferimento. Quando si vuole leggere il contenuto di un link simbolico si usa
 la funzione \func{readlink}, il cui prototipo è:
 \begin{prototype}{unistd.h}

-{int readlink(const char * path, char * buff, size\_t size)} 
+{int readlink(const char *path, char *buff, size\_t size)} 

   Legge il contenuto del link simbolico indicato da \var{path} nel buffer
   \var{buff} di dimensione \var{size}.
   
   Legge il contenuto del link simbolico indicato da \var{path} nel buffer
   \var{buff} di dimensione \var{size}.
   


@@ -401,8 +401,8 @@ interno un link simbolico che punta di nuovo a \file{/boot}\footnote{Questo
 Questo può causare problemi per tutti quei programmi che effettuano la
 scansione di una directory senza tener conto dei link simbolici, ad esempio se
 lanciassimo un comando del tipo \cmd{grep -r linux *}, il loop nella directory
 Questo può causare problemi per tutti quei programmi che effettuano la
 scansione di una directory senza tener conto dei link simbolici, ad esempio se
 lanciassimo un comando del tipo \cmd{grep -r linux *}, il loop nella directory

-porterebbe il comando ad esaminare \file{/boot}, \file/{boot/boot},
-\file/{boot/boot/boot} e così via.
+porterebbe il comando ad esaminare \file{/boot}, \file{/boot/boot},
+\file{/boot/boot/boot} e così via.

 
 Per questo motivo il kernel e le librerie prevedono che nella risoluzione di
 un pathname possano essere seguiti un numero limitato di link simbolici, il
 
 Per questo motivo il kernel e le librerie prevedono che nella risoluzione di
 un pathname possano essere seguiti un numero limitato di link simbolici, il


@@ -428,15 +428,15 @@ con un errore che pu
 mostrerebbe l'esistenza di \file{temporaneo}.
 
 
 mostrerebbe l'esistenza di \file{temporaneo}.
 
 

-\subsection{Le funzioni \func{mkdir} e \func{rmdir}} 
+\subsection{La creazione e la cancellazione delle directory} 

 \label{sec:file_dir_creat_rem}
 
 \label{sec:file_dir_creat_rem}
 

-Queste due funzioni servono per creare e cancellare delle directory e sono
-omonime degli analoghi comandi di shell.  Per poter accedere ai tipi usati
-da queste funzioni si deve includere il file \file{sys/types.h}, il
-prototipo della prima è:
+Per creare e cancellare delle directory si usano le due funzioni (omonime
+degli analoghi comandi di shell) \func{mkdir} e \func{rmdir}.  Per poter
+accedere ai tipi usati da queste funzioni si deve includere il file
+\file{sys/types.h}, il prototipo della prima è:

 \begin{prototype}{sys/stat.h}
 \begin{prototype}{sys/stat.h}

-  {int mkdir (const char * dirname, mode\_t mode)} 
+  {int mkdir(const char *dirname, mode\_t mode)} 

   Crea una nuova directory vuota con il nome indicato da \var{dirname},
   assegnandole i permessi indicati da \var{mode}. Il nome può essere indicato
   con il pathname assoluto o relativo.
   Crea una nuova directory vuota con il nome indicato da \var{dirname},
   assegnandole i permessi indicati da \var{mode}. Il nome può essere indicato
   con il pathname assoluto o relativo.


@@ -472,10 +472,9 @@ titolarit
 La seconda funzione serve ad eliminare una directory già vuota (la directory
 deve cioè contenere soltanto le due voci standard \file{.} e \file{..}); il
 suo prototipo è:
 La seconda funzione serve ad eliminare una directory già vuota (la directory
 deve cioè contenere soltanto le due voci standard \file{.} e \file{..}); il
 suo prototipo è:

-\begin{prototype}{sys/stat.h}
-  {int rmdir (const char * dirname)} Cancella la directory \var{dirname}, che
-  deve essere vuota.  Il nome può essere indicato con il pathname assoluto o
-  relativo.
+\begin{prototype}{sys/stat.h}{int rmdir(const char *dirname)} 
+  Cancella la directory \var{dirname}, che deve essere vuota.  Il nome può
+  essere indicato con il pathname assoluto o relativo.

   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso \var{errno} assumerà i valori:
   
   \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
     errore, nel qual caso \var{errno} assumerà i valori:


@@ -497,12 +496,78 @@ suo prototipo 
 \end{prototype}
 
 La modalità con cui avviene la cancellazione è analoga a quella di
 \end{prototype}
 
 La modalità con cui avviene la cancellazione è analoga a quella di

-\func{unlink}, fintanto che il numero di link all'inode della directory non
+\func{unlink}: fintanto che il numero di link all'inode della directory non

 diventa nullo e nessun processo ha la directory aperta lo spazio occupato su
 disco non viene rilasciato. Se un processo ha la directory aperta la funzione
 rimuove il link all'inode e nel caso sia l'ultimo, pure le voci standard
 diventa nullo e nessun processo ha la directory aperta lo spazio occupato su
 disco non viene rilasciato. Se un processo ha la directory aperta la funzione
 rimuove il link all'inode e nel caso sia l'ultimo, pure le voci standard

-\file{.} e \file{..}, ed il kernel non consentirà di creare più nuovi file
-nella directory.
+\file{.} e \file{..}, a questo punto il kernel non consentirà di creare più
+nuovi file nella directory.
+
+
+\subsection{La creazione di file speciali}
+\label{sec:file_mknod}
+
+Finora abbiamo parlato esclusivamente di file, directory e link simbolici; in
+\secref{sec:file_file_types} abbiamo visto però che il sistema preveda pure
+degli altri tipi di file, come i file di dispositivo e le fifo (i socket sono
+un caso a parte, che vedremo in \secref{cha:socket_intro}). 
+
+La manipolazione delle caratteristiche di questi filee e la loro cancellazione
+può essere effettuata con le stesse funzioni che operano sui file normali; ma
+quando li si devono creare sono necessarie delle funzioni apposite. 
+
+\begin{functions}
+  \headdecl{sys/types.h}
+  \headdecl{sys/stat.h}
+  \headdecl{fnctl.h}
+  \headdecl{unistd.h}
+  \funcdecl{int mknod(const char *pathname, mode\_t mode, dev\_t dev)} 
+  
+  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+    errore, nel qual caso \var{errno} assumerà i valori:
+  \begin{errlist}
+  \item[\macro{EPERM}] Il filesystem non supporta la cancellazione di
+    directory, oppure la directory che contiene \var{dirname} ha lo sticky bit
+    settato e l'\textit{effective user id} del processo non corrisponde al
+    proprietario della directory. 
+  \item[\macro{EACCESS}] Non c'è il permesso di scrittura per la directory che
+    contiene la directory che si vuole cancellare, o non c'è il permesso di
+    attraversare (esecuzione) una delle directory specificate in
+    \var{dirname}.
+  \item[\macro{EBUSY}] La directory specificata è la directory di lavoro o la
+    radice di qualche processo.
+  \item[\macro{ENOTEMPTY}] La directory non è vuota.
+  \end{errlist}
+  ed inoltre anche \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
+  \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP}, \macro{EROFS}.}
+\end{functions}
+
+
+\begin{functions}
+  \headdecl{sys/types.h}
+  \headdecl{sys/stat.h}
+  \funcdecl{int mkfifo(const char *pathname, mode\_t mode)} 
+  
+  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+    errore, nel qual caso \var{errno} assumerà i valori:
+  \begin{errlist}
+  \item[\macro{EPERM}] Il filesystem non supporta la cancellazione di
+    directory, oppure la directory che contiene \var{dirname} ha lo sticky bit
+    settato e l'\textit{effective user id} del processo non corrisponde al
+    proprietario della directory. 
+  \item[\macro{EACCESS}] Non c'è il permesso di scrittura per la directory che
+    contiene la directory che si vuole cancellare, o non c'è il permesso di
+    attraversare (esecuzione) una delle directory specificate in
+    \var{dirname}.
+  \item[\macro{EBUSY}] La directory specificata è la directory di lavoro o la
+    radice di qualche processo.
+  \item[\macro{ENOTEMPTY}] La directory non è vuota.
+  \end{errlist}
+  ed inoltre anche \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
+  \macro{ENOTDIR}, \macro{ENOMEM}, \macro{ELOOP}, \macro{EROFS}.}
+\end{functions}
+
+

 
 
 \subsection{Accesso alle directory}
 
 
 \subsection{Accesso alle directory}


@@ -511,17 +576,17 @@ nella directory.
 Benché le directory siano oggetti del filesystem come tutti gli altri non ha
 ovviamente senso aprirle come fossero dei file di dati. Può però essere utile
 poterne leggere il contenuto ad esempio per fare la lista dei file che esse
 Benché le directory siano oggetti del filesystem come tutti gli altri non ha
 ovviamente senso aprirle come fossero dei file di dati. Può però essere utile
 poterne leggere il contenuto ad esempio per fare la lista dei file che esse

-contengono o ricerche sui medesimi. Solo il kernel scrivere direttamente in
-una directory (onde evitare inconsistenze all'interno del filesystem), i
+contengono o ricerche sui medesimi. Solo il kernel può scrivere direttamente
+in una directory (onde evitare inconsistenze all'interno del filesystem), i

 processi devono creare i file usando le apposite funzioni.
 
 Per accedere al contenuto delle directory si usano i cosiddetti
 processi devono creare i file usando le apposite funzioni.
 
 Per accedere al contenuto delle directory si usano i cosiddetti

-\textit{directory streams} (chiamati così per l'analogia con i file stream);
-la funzione \func{opendir} apre uno di questi stream e la funzione
-\func{readdir} legge il contenuto della directory, i cui elementi sono le
-\textit{directory entry} (da distinguersi da quelle della cache di cui
-parlavamo in \secref{sec:file_vfs}) in una opportuna struttura \var{struct
-  dirent}.
+\textit{directory streams} (chiamati così per l'analogia con i file stream di
+\capref{che:file_std_interface}); la funzione \func{opendir} apre uno di
+questi stream e la funzione \func{readdir} legge il contenuto della directory,
+i cui elementi sono le \textit{directory entry} (da distinguersi da quelle
+della cache di cui parlavamo in \secref{sec:file_vfs}) in una opportuna
+struttura \var{struct dirent}.

 
 (NdA Il resto va scritto!!! É noioso e lo farò più avanti).
 
 
 (NdA Il resto va scritto!!! É noioso e lo farò più avanti).
 


@@ -545,7 +610,7 @@ directory corrente di qualunque comando da essa lanciato.
 In genere il kernel tiene traccia per ciascun processo dell'inode della
 directory di lavoro corrente, per ottenere il pathname occorre usare una
 apposita funzione di libreria,  \func{getcwd}, il cui prototipo è:
 In genere il kernel tiene traccia per ciascun processo dell'inode della
 directory di lavoro corrente, per ottenere il pathname occorre usare una
 apposita funzione di libreria,  \func{getcwd}, il cui prototipo è:

-\begin{prototype}{unistd.h}{char * getcwd (char * buffer, size\_t size)}
+\begin{prototype}{unistd.h}{char *getcwd(char *buffer, size\_t size)}

   Restituisce il filename completo della directory di lavoro corrente nella
   stringa puntata da \var{buffer}, che deve essere precedentemente
   allocata, per una dimensione massima di \var{size}.
   Restituisce il filename completo della directory di lavoro corrente nella
   stringa puntata da \var{buffer}, che deve essere precedentemente
   allocata, per una dimensione massima di \var{size}.


@@ -574,7 +639,7 @@ qualora questa sia diversa da zero, o della lunghezza esatta del pathname
 altrimenti. In questo caso ci si deve ricordare di disallocare la stringa una
 volta cessato il suo utilizzo.
 
 altrimenti. In questo caso ci si deve ricordare di disallocare la stringa una
 volta cessato il suo utilizzo.
 

-Di questa funzione esiste una versione \func{char * getwd(char * buffer)}
+Di questa funzione esiste una versione \code{char *getwd(char *buffer)}

 fatta per compatibilità all'indietro con BSD, che non consente di specificare
 la dimensione del buffer; esso deve essere allocato in precedenza ed avere una
 dimensione superiore a \macro{PATH\_MAX} (di solito 256 byte, vedi
 fatta per compatibilità all'indietro con BSD, che non consente di specificare
 la dimensione del buffer; esso deve essere allocato in precedenza ed avere una
 dimensione superiore a \macro{PATH\_MAX} (di solito 256 byte, vedi


@@ -583,11 +648,11 @@ superiore per un pathname, per cui non 
 contenere il nome del file, e questa è la ragione principale per cui questa
 funzione è deprecata.
 
 contenere il nome del file, e questa è la ragione principale per cui questa
 funzione è deprecata.
 

-Una seconda funzione simile è \func{char * get\_current\_dir\_name(void)} che
-è sostanzialmente equivalente ad una \func{getcwd(NULL, 0)}, con la sola
+Una seconda funzione simile è \code{char *get\_current\_dir\_name(void)} che è
+sostanzialmente equivalente ad una \code{getcwd(NULL, 0)}, con la sola

 differenza che essa ritorna il valore della variabile di ambiente \macro{PWD},
 che essendo costruita dalla shell può contenere anche dei riferimenti
 differenza che essa ritorna il valore della variabile di ambiente \macro{PWD},
 che essendo costruita dalla shell può contenere anche dei riferimenti

-simbolici; nel caso di  \func{getcwd} infatti, essendo il pathname ricavato
+simbolici; nel caso di \func{getcwd} infatti, essendo il pathname ricavato

 risalendo all'indietro l'albero della directory, si perderebbe traccia di ogni
 passaggio attraverso eventuali pathname.
 
 risalendo all'indietro l'albero della directory, si perderebbe traccia di ogni
 passaggio attraverso eventuali pathname.
 


@@ -598,20 +663,21 @@ ad esse anche tramite il file descriptor dell'interfaccia a basso livello, e
 non solo tramite il filename, i prototipi di queste funzioni sono:
 \begin{functions}
   \headdecl{unistd.h} 
 non solo tramite il filename, i prototipi di queste funzioni sono:
 \begin{functions}
   \headdecl{unistd.h} 

-  \funcdecl{int chdir (const char * path)} 
+  \funcdecl{int chdir(const char *path)} 

   Cambia la directory di lavoro corrente a quella specificata dal pathname
   contenuto nella stringa \var{path}.
   
   Cambia la directory di lavoro corrente a quella specificata dal pathname
   contenuto nella stringa \var{path}.
   

-  \funcdecl{int fchdir (int fd)} Analoga alla precedente, ma
-  usa un file descriptor invece del pathname.
+  \funcdecl{int fchdir(int fd)} Analoga alla precedente, ma usa un file
+  descriptor invece del pathname.

   
   \bodydesc{Entrambe le funzioni restituiscono zero in caso di successo
     e -1 per un errore, in caso di errore \var{errno} viene settata per
     \func{chdir} ai valori:
   \begin{errlist}
   
   \bodydesc{Entrambe le funzioni restituiscono zero in caso di successo
     e -1 per un errore, in caso di errore \var{errno} viene settata per
     \func{chdir} ai valori:
   \begin{errlist}

-  \item[\macro{ENOTDIR}] Uno dei componenti di \var{path} non è una directory. 
+  \item[\macro{ENOTDIR}] Uno dei componenti di \param{path} non è una
+    directory.

   \item[\macro{EACCESS}] Manca il permesso di ricerca su uno dei componenti di
   \item[\macro{EACCESS}] Manca il permesso di ricerca su uno dei componenti di

-    \func{path}.
+    \param{path}.

   \end{errlist}
   ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
   \macro{ENOMEM}, \macro{ELOOP} e \macro{EIO}. Per \func{fchdir} invece gli
   \end{errlist}
   ed inoltre \macro{EFAULT}, \macro{ENAMETOOLONG}, \macro{ENOENT},
   \macro{ENOMEM}, \macro{ELOOP} e \macro{EIO}. Per \func{fchdir} invece gli


@@ -620,6 +686,15 @@ non solo tramite il filename, i prototipi di queste funzioni sono:
 
 
 
 
 
 

+\subsection{I file temporanei}
+\label{sec:file_temp_file}
+
+Un'altra serie di funzioni definite dalle librerie standard del C sono quelle
+che riguardano la creazione di file temporanei. 
+
+
+
+

 \section{La manipolazione delle caratteristiche dei files}
 \label{sec:file_infos}
 
 \section{La manipolazione delle caratteristiche dei files}
 \label{sec:file_infos}
 


@@ -813,7 +888,7 @@ Si tenga conto che lunghezza del file riportata in \var{st\_size} non 
 che corrisponda all'occupazione dello spazio su disco per via della possibile
 esistenza dei cosiddetti \textsl{buchi} (detti normalmente \textit{holes}) che
 si formano tutte le volte che si va a scrivere su un file dopo aver eseguito
 che corrisponda all'occupazione dello spazio su disco per via della possibile
 esistenza dei cosiddetti \textsl{buchi} (detti normalmente \textit{holes}) che
 si formano tutte le volte che si va a scrivere su un file dopo aver eseguito

-una \func{seek} (vedi \secref{sec:file_lseek}) oltre la sua conclusione
+una \func{lseek} (vedi \secref{sec:file_lseek}) oltre la sua conclusione

 corrente.
 
 In tal caso si avranno differenti risultati a seconda del modi in cui si
 corrente.
 
 In tal caso si avranno differenti risultati a seconda del modi in cui si


@@ -824,7 +899,7 @@ caso per le parti non scritte vengono restituiti degli zeri, si avr
 risultato di \cmd{ls}.
 
 Se è sempre possibile allargare un file, scrivendoci sopra od usando la
 risultato di \cmd{ls}.
 
 Se è sempre possibile allargare un file, scrivendoci sopra od usando la

-funzione \func{seek} per spostarsi oltre la sua fine, esistono anche casi in
+funzione \func{lseek} per spostarsi oltre la sua fine, esistono anche casi in

 cui si può avere bisogno di effettuare un troncamento, scartando i dati
 presenti al di là della dimensione scelta come nuova fine del file.
 
 cui si può avere bisogno di effettuare un troncamento, scartando i dati
 presenti al di là della dimensione scelta come nuova fine del file.
 


@@ -1016,17 +1091,17 @@ avr
 I tempi di ultimo accesso e modifica possono essere cambiati usando la
 funzione \func{utime}, il cui prototipo è:
 \begin{prototype}{utime.h}
 I tempi di ultimo accesso e modifica possono essere cambiati usando la
 funzione \func{utime}, il cui prototipo è:
 \begin{prototype}{utime.h}

-{int utime(const char * filename, struct utimbuf *times)} 
+{int utime(const char *filename, struct utimbuf *times)} 

 
 Cambia i tempi di ultimo accesso e modifica dell'inode specificato da
 
 Cambia i tempi di ultimo accesso e modifica dell'inode specificato da

-\var{filename} secondo i campi \var{actime} e \var{modtime} di \var{times}. Se
-questa è \macro{NULL} allora viene usato il tempo corrente.
+\param{filename} secondo i campi \var{actime} e \var{modtime} di
+\param{times}. Se questa è \macro{NULL} allora viene usato il tempo corrente.

 
 \bodydesc{La funzione restituisce zero in caso di successo e -1 in caso
   di errore, nel qual caso \var{errno} è settata opportunamente.
 \begin{errlist}
 \item[\macro{EACCESS}] non si ha il permesso di scrittura sul file.
 
 \bodydesc{La funzione restituisce zero in caso di successo e -1 in caso
   di errore, nel qual caso \var{errno} è settata opportunamente.
 \begin{errlist}
 \item[\macro{EACCESS}] non si ha il permesso di scrittura sul file.

-\item[\macro{ENOENT}] \var{filename} non esiste.
+\item[\macro{ENOENT}] \param{filename} non esiste.

 \end{errlist}}
 \end{prototype}
  
 \end{errlist}}
 \end{prototype}
  


@@ -1039,7 +1114,7 @@ struct utimbuf {
 \end{lstlisting}
 
 L'effetto della funzione e i privilegi necessari per eseguirla dipendono da
 \end{lstlisting}
 
 L'effetto della funzione e i privilegi necessari per eseguirla dipendono da

-cosa è l'argomento \var{times}; se è \macro{NULL} la funzione setta il tempo
+cosa è l'argomento \param{times}; se è \macro{NULL} la funzione setta il tempo

 corrente ed è sufficiente avere accesso in scrittura al file; se invece si è
 specificato un valore la funzione avrà successo solo se si è proprietari del
 file (o si hanno i privilegi di amministratore).
 corrente ed è sufficiente avere accesso in scrittura al file; se invece si è
 specificato un valore la funzione avrà successo solo se si è proprietari del
 file (o si hanno i privilegi di amministratore).


@@ -1204,7 +1279,7 @@ dell'utente che ha lanciato il processo, mentre i \textit{supplementary group
 
 I passi attraverso i quali viene stabilito se il processo possiede il diritto
 di accesso sono i seguenti:
 
 I passi attraverso i quali viene stabilito se il processo possiede il diritto
 di accesso sono i seguenti:

-\begin{itemize}
+\begin{enumerate}

 \item Se l'\textit{effective user id} del processo è zero (corrispondente
   all'amministratore) l'accesso è sempre garantito senza nessun ulteriore
   controllo. Per questo motivo \textsl{root} ha piena libertà di accesso a
 \item Se l'\textit{effective user id} del processo è zero (corrispondente
   all'amministratore) l'accesso è sempre garantito senza nessun ulteriore
   controllo. Per questo motivo \textsl{root} ha piena libertà di accesso a


@@ -1212,24 +1287,24 @@ di accesso sono i seguenti:
 \item Se l'\textit{effective user id} del processo è uguale all'\acr{uid} del
   proprietario del file (nel qual caso si dice che il processo è proprietario
   del file) allora:
 \item Se l'\textit{effective user id} del processo è uguale all'\acr{uid} del
   proprietario del file (nel qual caso si dice che il processo è proprietario
   del file) allora:

-  \begin{itemize}
+  \begin{itemize*}

   \item se il relativo\footnote{per relativo si intende il bit di user-read se
       il processo vuole accedere in scrittura, quello di user-write per
       l'accesso in scrittura, etc.} bit dei permessi d'accesso dell'utente è
     settato, l'accesso è consentito
   \item altrimenti l'accesso è negato
   \item se il relativo\footnote{per relativo si intende il bit di user-read se
       il processo vuole accedere in scrittura, quello di user-write per
       l'accesso in scrittura, etc.} bit dei permessi d'accesso dell'utente è
     settato, l'accesso è consentito
   \item altrimenti l'accesso è negato

-  \end{itemize}
+  \end{itemize*}

 \item Se l'\textit{effective group id} del processo o uno dei
   \textit{supplementary group id} dei processi corrispondono al \acr{gid} del
   file allora:
 \item Se l'\textit{effective group id} del processo o uno dei
   \textit{supplementary group id} dei processi corrispondono al \acr{gid} del
   file allora:

-  \begin{itemize}
+  \begin{itemize*}

   \item se il bit dei permessi d'accesso del gruppo è settato, l'accesso è
     consentito, 
   \item altrimenti l'accesso è negato
   \item se il bit dei permessi d'accesso del gruppo è settato, l'accesso è
     consentito, 
   \item altrimenti l'accesso è negato

-  \end{itemize}
+  \end{itemize*}

 \item se il bit dei permessi d'accesso per tutti gli altri è settato,
   l'accesso è consentito, altrimenti l'accesso è negato.
 \item se il bit dei permessi d'accesso per tutti gli altri è settato,
   l'accesso è consentito, altrimenti l'accesso è negato.

-\end{itemize}
+\end{enumerate}

 
 Si tenga presente che questi passi vengono eseguiti esattamente in
 quest'ordine. Questo vuol dire che se un processo è il proprietario di un file
 
 Si tenga presente che questi passi vengono eseguiti esattamente in
 quest'ordine. Questo vuol dire che se un processo è il proprietario di un file


@@ -1331,11 +1406,11 @@ assunto un uso corrente per le directory\footnote{lo \textsl{sticky bit} per
   la supporta, così come BSD e SVR4}, in questo caso se il bit è settato un
 file potrà essere rimosso dalla directory soltanto se l'utente ha il permesso
 di scrittura ed inoltre è vera una delle seguenti condizioni:
   la supporta, così come BSD e SVR4}, in questo caso se il bit è settato un
 file potrà essere rimosso dalla directory soltanto se l'utente ha il permesso
 di scrittura ed inoltre è vera una delle seguenti condizioni:

-\begin{itemize}
+\begin{itemize*}

 \item l'utente è proprietario del file
 \item l'utente è proprietario della directory
 \item l'utente è l'amministratore 
 \item l'utente è proprietario del file
 \item l'utente è proprietario della directory
 \item l'utente è l'amministratore 

-\end{itemize}
+\end{itemize*}

 un classico esempio di directory che ha questo bit settato è \file{/tmp}, i
 permessi infatti di solito sono settati come:
 \begin{verbatim}
 un classico esempio di directory che ha questo bit settato è \file{/tmp}, i
 permessi infatti di solito sono settati come:
 \begin{verbatim}


@@ -1360,12 +1435,12 @@ descritto in \secref{sec:file_dir_creat_rem}).
 Lo standard POSIX prescrive che l'\acr{uid} del nuovo file corrisponda
 all'\textit{effective user id} del processo che lo crea; per il \acr{gid}
 invece prevede due diverse possibilità:
 Lo standard POSIX prescrive che l'\acr{uid} del nuovo file corrisponda
 all'\textit{effective user id} del processo che lo crea; per il \acr{gid}
 invece prevede due diverse possibilità:

-\begin{itemize}
+\begin{itemize*}

 \item il \acr{gid} del file corrisponde all'\textit{effective group id} del
   processo.
 \item il \acr{gid} del file corrisponde al \acr{gid} della directory in cui
   esso è creato.
 \item il \acr{gid} del file corrisponde all'\textit{effective group id} del
   processo.
 \item il \acr{gid} del file corrisponde al \acr{gid} della directory in cui
   esso è creato.

-\end{itemize}
+\end{itemize*}

 in genere BSD usa sempre la seconda possibilità, che viene per questo chiamata
 semantica BSD. Linux invece segue quella che viene chiamata semantica SVr4; di
 norma cioè il nuovo file viene creato, seguendo la prima opzione, con il
 in genere BSD usa sempre la seconda possibilità, che viene per questo chiamata
 semantica BSD. Linux invece segue quella che viene chiamata semantica SVr4; di
 norma cioè il nuovo file viene creato, seguendo la prima opzione, con il


@@ -1518,7 +1593,7 @@ Il cambiamento dei permessi di un file attraverso queste funzioni ha comunque
 alcune limitazioni, provviste per motivi di sicurezza. Questo significa che
 anche se si è proprietari del file non tutte le operazioni sono permesse, in
 particolare:
 alcune limitazioni, provviste per motivi di sicurezza. Questo significa che
 anche se si è proprietari del file non tutte le operazioni sono permesse, in
 particolare:

-\begin{itemize}
+\begin{enumerate}

 \item siccome solo l'amministratore può settare lo \textit{sticky bit}; se
   l'\textit{effective user id} del processo non è zero esso viene
   automaticamente cancellato (senza notifica di errore) qualora sia stato
 \item siccome solo l'amministratore può settare lo \textit{sticky bit}; se
   l'\textit{effective user id} del processo non è zero esso viene
   automaticamente cancellato (senza notifica di errore) qualora sia stato


@@ -1531,7 +1606,7 @@ particolare:
   notifica di errore) da \var{mode} qualora il gruppo del file non corrisponda
   a quelli associati al processo (la cosa non avviene quando
   l'\textit{effective user id} del processo è zero).
   notifica di errore) da \var{mode} qualora il gruppo del file non corrisponda
   a quelli associati al processo (la cosa non avviene quando
   l'\textit{effective user id} del processo è zero).

-\end{itemize}
+\end{enumerate}

 
 Per alcuni filesystem\footnote{il filesystem \acr{ext2} supporta questa
   caratteristica, che è mutuata da BSD.} è inoltre prevista una ulteriore
 
 Per alcuni filesystem\footnote{il filesystem \acr{ext2} supporta questa
   caratteristica, che è mutuata da BSD.} è inoltre prevista una ulteriore


@@ -1637,4 +1712,3 @@ che per il file 
 %completo vedi \ntab), i permessi (vedi \secref{sec:file_perms}), le date (vedi
 %\secref{sec:file_times}).
 
 %completo vedi \ntab), i permessi (vedi \secref{sec:file_perms}), le date (vedi
 %\secref{sec:file_times}).
 

-

diff --git a/fileintro.tex b/fileintro.tex
index 24fec34cbc44e70992e40650c676d41108529082..47e002c1c5373919527ef7a72bbb8be251bc15f5 100644 (file)
--- a/fileintro.tex
+++ b/fileintro.tex
@@ -359,7 +359,7 @@ e file, corrispondenti a tre apposite strutture definite nel kernel.
 Il VFS usa una tabella mantenuta dal kernel che contiene il nome di ciascun
 filesystem supportato: quando si vuole inserire il supporto di un nuovo
 filesystem tutto quello che occorre è chiamare la funzione
 Il VFS usa una tabella mantenuta dal kernel che contiene il nome di ciascun
 filesystem supportato: quando si vuole inserire il supporto di un nuovo
 filesystem tutto quello che occorre è chiamare la funzione

-\func{register\_filesystem} passandole un'apposita struttura
+\code{register\_filesystem} passandole un'apposita struttura

 (\var{file\_system\_type}) che contiene i dettagli per il riferimento
 all'implementazione del medesimo, che sarà aggiunta alla citata tabella.
 
 (\var{file\_system\_type}) che contiene i dettagli per il riferimento
 all'implementazione del medesimo, che sarà aggiunta alla citata tabella.
 


@@ -423,7 +423,7 @@ per i quali 
 pathname il VFS deve creare una nuova \textit{dentry} e caricare l'inode
 corrispondente in memoria.
 
 pathname il VFS deve creare una nuova \textit{dentry} e caricare l'inode
 corrispondente in memoria.
 

-Questo procedimento viene eseguito dal metodo \func{lookup()} dell'inode
+Questo procedimento viene eseguito dal metodo \code{lookup()} dell'inode

 della directory che contiene il file; questo viene installato nelle relative
 strutture in memoria quando si effettua il montaggio lo specifico filesystem
 su cui l'inode va a vivere.
 della directory che contiene il file; questo viene installato nelle relative
 strutture in memoria quando si effettua il montaggio lo specifico filesystem
 su cui l'inode va a vivere.


@@ -450,20 +450,20 @@ operazioni previste dal kernel 
     \textbf{Funzione} & \textbf{Operazione} \\
     \hline
     \hline
     \textbf{Funzione} & \textbf{Operazione} \\
     \hline
     \hline

-    \textsl{\func{open}}   & apre il file \\
-    \textsl{\func{read}}   & legge dal file \\
-    \textsl{\func{write}}  & scrive sul file \\ 
-    \textsl{\func{llseek}} & sposta la posizione corrente sul file \\
-    \textsl{\func{ioctl}}  & accede alle operazioni di controllo 
+    \textsl{\code{open}}   & apre il file \\
+    \textsl{\code{read}}   & legge dal file \\
+    \textsl{\code{write}}  & scrive sul file \\ 
+    \textsl{\code{llseek}} & sposta la posizione corrente sul file \\
+    \textsl{\code{ioctl}}  & accede alle operazioni di controllo 

                        (tramite la \func{ioctl})\\
                        (tramite la \func{ioctl})\\

-    \textsl{\func{readdir}}& per leggere il contenuto di una directory \\
-    \textsl{\func{poll}}   & \\
-    \textsl{\func{mmap}}   & chiamata dalla system call \func{mmap}. 
+    \textsl{\code{readdir}}& per leggere il contenuto di una directory \\
+    \textsl{\code{poll}}   & \\
+    \textsl{\code{mmap}}   & chiamata dalla system call \func{mmap}. 

                        mappa il file in memoria\\
                        mappa il file in memoria\\

-    \textsl{\func{release}}& chiamata quando l'ultima referenza a un file 
+    \textsl{\code{release}}& chiamata quando l'ultima referenza a un file 

                        aperto è chiusa\\
                        aperto è chiusa\\

-    \textsl{\func{fsync}}  & chiamata dalla system call \func{fsync} \\
-    \textsl{\func{fasync}} & chiamate da \func{fcntl} quando è abilitato 
+    \textsl{\code{fsync}}  & chiamata dalla system call \func{fsync} \\
+    \textsl{\code{fasync}} & chiamate da \func{fcntl} quando è abilitato 

                            il modo asincrono per l'I/O su file. \\
     \hline
   \end{tabular}
                            il modo asincrono per l'I/O su file. \\
     \hline
   \end{tabular}


@@ -479,7 +479,7 @@ di file in questione.
 
 Così sarà possibile scrivere sulla porta seriale come su un file di dati
 normale; ovviamente certe operazioni (nel caso della seriale ad esempio la
 
 Così sarà possibile scrivere sulla porta seriale come su un file di dati
 normale; ovviamente certe operazioni (nel caso della seriale ad esempio la

-\func{seek}) non saranno disponibili, però con questo sistema l'utilizzo di
+\code{seek}) non saranno disponibili, però con questo sistema l'utilizzo di

 diversi filesystem (come quelli usati da Windows o MacOs) è immediato e
 (relativamente) trasparente per l'utente ed il programmatore.
 
 diversi filesystem (come quelli usati da Windows o MacOs) è immediato e
 (relativamente) trasparente per l'utente ed il programmatore.
 

diff --git a/filestd.tex b/filestd.tex
index 6348a7daa0978b0a775ee32be414d44d5aea3943..13934c3ef8c8887751059e80306031caa8be86b4 100644 (file)
--- a/filestd.tex
+++ b/filestd.tex
@@ -228,7 +228,7 @@ prototipi sono:
     viene settata al valore ricevuto dalla funzione sottostante di cui è
     fallita l'esecuzione.
   
     viene settata al valore ricevuto dalla funzione sottostante di cui è
     fallita l'esecuzione.
   

-    Gli errori pertanto possono essere quelli di \func{malloc} per tutte
+    Gli errori pertanto possono essere quelli di \code{malloc} per tutte

     e tre le funzioni, quelli \func{open} per \func{fopen}, quelli di
     \func{fcntl} per \func{fdopen} e quelli di \func{fopen},
     \func{fclose} e \func{fflush} per \func{freopen}.}
     e tre le funzioni, quelli \func{open} per \func{fopen}, quelli di
     \func{fcntl} per \func{fdopen} e quelli di \func{fopen},
     \func{fclose} e \func{fflush} per \func{freopen}.}


@@ -284,7 +284,7 @@ possono essere aperti con le funzioni delle librerie standard del C.
 In realtà lo standard ANSI C prevede un totale di 15 possibili valori
 diversi per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono
 riportati solo i sei valori effettivi, ad essi può essere aggiunto pure
 In realtà lo standard ANSI C prevede un totale di 15 possibili valori
 diversi per \param{mode}, ma in \tabref{tab:file_fopen_mode} si sono
 riportati solo i sei valori effettivi, ad essi può essere aggiunto pure

-il carattere \func{b} (come ultimo carattere o nel mezzo agli altri per
+il carattere \texttt{b} (come ultimo carattere o nel mezzo agli altri per

 le stringhe di due caratteri) che in altri sistemi operativi serve a
 distinguere i file binari dai file di testo; in un sistema POSIX questa
 distinzione non esiste e il valore viene accettato solo per
 le stringhe di due caratteri) che in altri sistemi operativi serve a
 distinguere i file binari dai file di testo; in un sistema POSIX questa
 distinzione non esiste e il valore viene accettato solo per


@@ -330,7 +330,7 @@ una scrittura una delle funzioni \func{fflush}, \func{fseek}, \func{fsetpos} o
 \func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si
 voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima
 usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche
 \func{rewind} prima di eseguire una rilettura; viceversa nel caso in cui si
 voglia fare una scrittura subito dopo aver eseguito una lettura occorre prima
 usare una delle funzioni \func{fseek}, \func{fsetpos} o \func{rewind}. Anche

-una operazione nominalmente nulla come \func{fseek(file, 0, SEEK\_CUR)} è
+una operazione nominalmente nulla come \code{fseek(file, 0, SEEK\_CUR)} è

 sufficiente a garantire la sincronizzazione.
 
 Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione
 sufficiente a garantire la sincronizzazione.
 
 Una volta aperto lo stream, si può cambiare la modalità di bufferizzazione


@@ -396,7 +396,7 @@ 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 \type{int}) \macro{EOF}\footnote{la costante deve essere
   negativa, le \acr{glibc} usano -1, altre implementazioni possono avere
 maggior parte dei casi questo avviene con la restituzione del valore
 intero (di tipo \type{int}) \macro{EOF}\footnote{la costante deve essere
   negativa, le \acr{glibc} usano -1, altre implementazioni possono avere

-  valori diversi.}  definito anch'esso nell'header \func{stdlib.h}.
+  valori diversi.}  definito anch'esso nell'header \file{stdlib.h}.

 
 Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
 che si appoggiano a delle system call, esse non settano direttamente la
 
 Dato che le funzioni dell'interfaccia degli stream sono funzioni di libreria
 che si appoggiano a delle system call, esse non settano direttamente la


@@ -504,7 +504,7 @@ 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
 elemento. 
 
 In realtà quello che conta nel trasferimento dei dati sono le dimensioni

-totali, che sono sempre pari al prodotto \func{size * nelem}; la sola
+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.
 
 differenza è che le funzioni non ritornano il numero di byte scritti,
 ma il numero di elementi.
 


@@ -580,7 +580,7 @@ rispettivi prototipi sono:
   \funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
   restituisce come intero. È una sempre una funzione.
   
   \funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
   restituisce come intero. È una sempre una funzione.
   

-  \funcdecl{int getchar(void)} Equivalente a \func{getc(stdin)}.
+  \funcdecl{int getchar(void)} Equivalente a \code{getc(stdin)}.

   
   \bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
     restituito come intero; in caso di errore o fine del file il valore
   
   \bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
     restituito come intero; in caso di errore o fine del file il valore


@@ -621,7 +621,7 @@ byte restituiscono un carattere in formato esteso (cio
   \funcdecl{wint\_t fgetwc(FILE *stream)} Legge un carattere esteso da
   \param{stream} È una sempre una funzione.
   
   \funcdecl{wint\_t fgetwc(FILE *stream)} Legge un carattere esteso da
   \param{stream} È una sempre una funzione.
   

-  \funcdecl{wint\_t getwchar(void)} Equivalente a \func{getwc(stdin)}.
+  \funcdecl{wint\_t getwchar(void)} Equivalente a \code{getwc(stdin)}.

   
   \bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
     caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}
   
   \bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
     caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}


@@ -639,7 +639,7 @@ precedenti usate per leggere: \func{putc}, \func{fputc} e
   \funcdecl{int fputc(FILE *stream)} Scrive il carattere \param{c} su
   \param{stream}. È una sempre una funzione.
   
   \funcdecl{int fputc(FILE *stream)} Scrive il carattere \param{c} su
   \param{stream}. È una sempre una funzione.
   

-  \funcdecl{int putchar(void)} Equivalente a \func{putc(stdin)}.
+  \funcdecl{int putchar(void)} Equivalente a \code{putc(stdin)}.

   
   \bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
     valore viene restituito in caso di successo; in caso di errore o
   
   \bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
     valore viene restituito in caso di successo; in caso di errore o


@@ -654,7 +654,7 @@ sempre un intero; in caso di errore o fine del file il valore di ritorno
 
 Come nel caso dell'I/O binario le \acr{glibc} provvedono per ciascuna
 delle funzioni precedenti, come estensione GNU, una seconda funzione, il
 
 Come nel caso dell'I/O binario le \acr{glibc} provvedono per ciascuna
 delle funzioni precedenti, come estensione GNU, una seconda funzione, il

-cui nome è ottenuto aggiungendo un \func{\_unlocked}, che esegue
+cui nome è ottenuto aggiungendo un \code{\_unlocked}, che esegue

 esattamente le stesse operazioni evitando però il lock implicito dello
 stream.
 
 esattamente le stesse operazioni evitando però il lock implicito dello
 stream.
 


@@ -825,7 +825,7 @@ anzich
 Come nel caso dell'I/O binario e a caratteri nelle \acr{glibc} sono
 previste una serie di altre funzioni, estensione di tutte quelle
 illustrate finora (eccetto \func{gets} e \func{puts}), il cui nome si
 Come nel caso dell'I/O binario e a caratteri nelle \acr{glibc} sono
 previste una serie di altre funzioni, estensione di tutte quelle
 illustrate finora (eccetto \func{gets} e \func{puts}), il cui nome si

-ottiene aggiungendo un \func{\_unlocked}, e che eseguono esattamente le
+ottiene aggiungendo un \code{\_unlocked}, e che eseguono esattamente le

 stesse operazioni delle loro equivalenti, evitando però il lock
 implicito dello stream (vedi \secref{sec:file_stream_thread}).
 
 stesse operazioni delle loro equivalenti, evitando però il lock
 implicito dello stream (vedi \secref{sec:file_stream_thread}).
 


@@ -1151,8 +1151,8 @@ pi
 Infine una ulteriore estensione GNU definisce le due funzioni \func{dprintf} e
 \func{vdprintf}, che prendono un file descriptor al posto dello stream. Altre
 estensioni permettono di scrivere con caratteri estesi. Anche queste funzioni,
 Infine una ulteriore estensione GNU definisce le due funzioni \func{dprintf} e
 \func{vdprintf}, che prendono un file descriptor al posto dello stream. Altre
 estensioni permettono di scrivere con caratteri estesi. Anche queste funzioni,

-il cui nome è generato dalle precedenti funzioni aggiungendo una \func{w}
-davanti a \func{print}, sono trattate in dettaglio nella documentazione delle
+il cui nome è generato dalle precedenti funzioni aggiungendo una \texttt{w}
+davanti a \texttt{print}, sono trattate in dettaglio nella documentazione delle

 \acr{glibc}.
 
 In corrispondenza alla famiglia di funzioni \func{printf} che si usano per
 \acr{glibc}.
 
 In corrispondenza alla famiglia di funzioni \func{printf} che si usano per


@@ -1253,7 +1253,7 @@ particolare \param{whence} assume gli stessi valori gi
 \secref{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'inzio dello stream, ma non esattamente equivalente ad
 \secref{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'inzio dello stream, ma non esattamente equivalente ad

-una \func{fseek(stream, 0L, SEEK\_SET)} in quanto vengono cancellati anche i
+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 \func{ftell}, il
 flag di errore e fine del file.
 
 Per ottenere la posizione corrente si usa invece la funzione \func{ftell}, il


@@ -1278,10 +1278,10 @@ pu
   \headdecl{stdio.h} 
   
   \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione
   \headdecl{stdio.h} 
   
   \funcdecl{int fsetpos(FILE *stream, fpos\_t *pos)} Setta la posizione

-  corrente nello stream \param{stream} al valore specificato da \func{pos}.
+  corrente nello stream \param{stream} al valore specificato da \param{pos}.

   
   \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione
   
   \funcdecl{int fgetpos(FILE *stream, fpos\_t *pos)} Scrive la posizione

-  corrente nello stream \param{stream} in \func{pos}.
+  corrente nello stream \param{stream} in \param{pos}.

   
   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
     errore.}
   
   \bodydesc{Le funzioni ritornano 0 in caso di successo e -1 in caso di
     errore.}


@@ -1367,8 +1367,8 @@ suo prototipo 
 \begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode, 
     size\_t size)}
   
 \begin{prototype}{stdio.h}{int setvbuf(FILE *stream, char *buf, int mode, 
     size\_t size)}
   

-  Setta la bufferizzazione dello stream \func{stream} nella modalità indicata
-  da \param{mode}, usando \func{buf} come buffer di lunghezza \param{size}.
+  Setta la bufferizzazione dello stream \param{stream} nella modalità indicata
+  da \param{mode}, usando \param{buf} come buffer di lunghezza \param{size}.

   
   \bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
     caso di errore.}
   
   \bodydesc{Restituisce zero in caso di successo, ed un valore qualunque in
     caso di errore.}


@@ -1377,7 +1377,7 @@ suo prototipo 
 La funzione permette di controllare tutti gli aspetti della 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
 La funzione permette di controllare tutti gli aspetti della 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

-\func{size}. 
+\param{size}. 

 
 Ovviamente se si usa un buffer specificato dall'utente questo deve essere
 stato allocato e restare disponibile per tutto il tempo in cui si opera sullo
 
 Ovviamente se si usa un buffer specificato dall'utente questo deve essere
 stato allocato e restare disponibile per tutto il tempo in cui si opera sullo


@@ -1421,11 +1421,11 @@ e \func{setlinebuf}, i loro prototipi sono:
   \headdecl{stdio.h} 
   
   \funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la
   \headdecl{stdio.h} 
   
   \funcdecl{void setbuf(FILE *stream, char *buf)} Disabilita la

-  bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \func{buf}
+  bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}

   come buffer di dimensione \macro{BUFSIZ} in modalità \textit{fully buffered}.
   
   \funcdecl{void setbuffer(FILE *stream, char *buf, size\_t size)} Disabilita
   come buffer di dimensione \macro{BUFSIZ} in modalità \textit{fully buffered}.
   
   \funcdecl{void setbuffer(FILE *stream, char *buf, size\_t size)} Disabilita

-  la bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \func{buf}
+  la bufferizzazione se \param{buf} è \macro{NULL}, altrimenti usa \param{buf}

   come buffer di dimensione \param{size} in modalità \textit{fully buffered}.
   
   \funcdecl{void setlinebuf(FILE *stream)} Pone lo stream in modalità
   come buffer di dimensione \param{size} in modalità \textit{fully buffered}.
   
   \funcdecl{void setlinebuf(FILE *stream)} Pone lo stream in modalità


@@ -1495,7 +1495,7 @@ blocco non sono del tutto indolori, e quando il locking dello stream non 
 necessario (come in tutti i programmi che non usano i thread), tutta la
 procedura può comportare dei pesanti costi in termini di prestazioni. Per
 questo motivo abbiamo visto in come per tutte le funzioni di I/O non
 necessario (come in tutti i programmi che non usano i thread), tutta la
 procedura può comportare dei pesanti costi in termini di prestazioni. Per
 questo motivo abbiamo visto in come per tutte le funzioni di I/O non

-formattato esistano delle versioni \func{\_unlocked} (alcune previste dallo
+formattato esistano delle versioni \code{\_unlocked} (alcune previste dallo

 standard POSIX stesso, altre aggiunte come estenzioni dalle \acr{glibc}) che
 possono essere usate in tutti questi casi\footnote{in certi casi dette
   funzioni possono essere usate, visto che sono molto più efficiente, anche in
 standard POSIX stesso, altre aggiunte come estenzioni dalle \acr{glibc}) che
 possono essere usate in tutti questi casi\footnote{in certi casi dette
   funzioni possono essere usate, visto che sono molto più efficiente, anche in


@@ -1505,7 +1505,7 @@ possono essere usate in tutti questi casi\footnote{in certi casi dette
 pertanto in grado di garantire prestazione enormemente più elevate.
 
 La sostituizione di tutte le funzioni di I/O con le relative versioni
 pertanto in grado di garantire prestazione enormemente più elevate.
 
 La sostituizione di tutte le funzioni di I/O con le relative versioni

-\func{\_unlocked} in un programma che non usa i thread è però un lavoro
+\code{\_unlocked} in un programma che non usa i thread è però un lavoro

 abbastanza noioso, e che appesantisce il codice; per questo motivo le
 \acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il
 locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso
 abbastanza noioso, e che appesantisce il codice; per questo motivo le
 \acr{glibc} provvedono un'altra via per poter utilizzare disabilitare il
 locking, anch'essa mutuata da estensioni introdotte in Solaris, cioè l'uso


@@ -1528,9 +1528,3 @@ della funzione \func{\_\_fsetlocking}, il cui prototipo 
   di blocco dello stream.
 \end{basedescript}
 
   di blocco dello stream.
 \end{basedescript}
 

-
-\subsection{File temporanei}
-\label{sec:file_temp_file}
-
-Un'altra serie di funzioni definite dalle librerie standard del C sono quelle
-che riguardano la creazione di file temporanei. 

diff --git a/fileunix.tex b/fileunix.tex
index bfbe8930e9917d65b1fd3b99418dfa1f0f811ae8..d321ee98233d908f3879fa3f200293aecc56e1e8 100644 (file)
--- a/fileunix.tex
+++ b/fileunix.tex
@@ -364,7 +364,7 @@ prototipo 
 \begin{prototype}{fcntl.h}
   {int creat(const char *pathname, mode\_t mode)}
   Crea un nuovo file vuoto, con i permessi specificati da \var{mode}. É del
 \begin{prototype}{fcntl.h}
   {int creat(const char *pathname, mode\_t mode)}
   Crea un nuovo file vuoto, con i permessi specificati da \var{mode}. É del

-  tutto equivalente a \func{open(filedes, O\_CREAT|O\_WRONLY|O\_TRUNC, mode)}. 
+  tutto equivalente a \code{open(filedes, O\_CREAT|O\_WRONLY|O\_TRUNC, mode)}. 

 \end{prototype}
 \noindent adesso questa funzione resta solo per compatibilità con i vecchi 
 programmi.
 \end{prototype}
 \noindent adesso questa funzione resta solo per compatibilità con i vecchi 
 programmi.


@@ -437,14 +437,14 @@ un valore qualsiasi con la funzione \func{lseek}, il cui prototipo 
     successo e -1 in caso di errore nel qual caso \var{errno} viene settata ad
     uno dei valori:
   \begin{errlist}
     successo e -1 in caso di errore nel qual caso \var{errno} viene settata ad
     uno dei valori:
   \begin{errlist}

-    \item[\macro{ESPIPE}] \var{fd} è una pipe, un socket o una fifo.
-    \item[\macro{EINVAL}] \var{whence} non è un valore valido.
+    \item[\macro{ESPIPE}] \param{fd} è una pipe, un socket o una fifo.
+    \item[\macro{EINVAL}] \param{whence} non è un valore valido.

   \end{errlist}
   ed inoltre \macro{EBADF}.}
 \end{functions}
 
   \end{errlist}
   ed inoltre \macro{EBADF}.}
 \end{functions}
 

-La nuova posizione è settata usando il valore specificato da \var{offset},
-sommato al riferimento dato da \var{whence}; quest'ultimo può assumere i
+La nuova posizione è settata usando il valore specificato da \param{offset},
+sommato al riferimento dato da \param{whence}; quest'ultimo può assumere i

 seguenti valori\footnote{per compatibilità con alcune vecchie notazioni
   questi valori possono essere rimpiazzati rispettivamente con 0, 1 e 2 o con
   \macro{L\_SET}, \macro{L\_INCR} e \macro{L\_XTND}}:
 seguenti valori\footnote{per compatibilità con alcune vecchie notazioni
   questi valori possono essere rimpiazzati rispettivamente con 0, 1 e 2 o con
   \macro{L\_SET}, \macro{L\_INCR} e \macro{L\_XTND}}:


@@ -464,8 +464,8 @@ attivit
 kernel (cioè \var{f\_pos} in \var{file}, vedi \figref{fig:file_proc_file}).
 
 Dato che la funzione ritorna la nuova posizione, usando il valore zero per
 kernel (cioè \var{f\_pos} in \var{file}, vedi \figref{fig:file_proc_file}).
 
 Dato che la funzione ritorna la nuova posizione, usando il valore zero per

-\func{offset} si può riottenere la posizione corrente nel file chiamando la
-funzione con \func{lseek(fd, 0, SEEK\_CUR}. 
+\param{offset} si può riottenere la posizione corrente nel file chiamando la
+funzione con \code{lseek(fd, 0, SEEK\_CUR}. 

 
 Si tenga presente inoltre che usare \macro{SEEK\_END} non assicura affatto che
 successiva scrittura avvenga alla fine del file, infatti se questo è stato
 
 Si tenga presente inoltre che usare \macro{SEEK\_END} non assicura affatto che
 successiva scrittura avvenga alla fine del file, infatti se questo è stato


@@ -542,8 +542,8 @@ Lo stesso comportamento avviene caso di lettura dalla rete (cio
 come vedremo in \secref{sec:sock_io_behav}), o per certi dispositivi, come le
 unità a nastro, che restituiscono un singolo blocco di dati alla volta.
 
 come vedremo in \secref{sec:sock_io_behav}), o per certi dispositivi, come le
 unità a nastro, che restituiscono un singolo blocco di dati alla volta.
 

-In realtà anche le due condizioni segnalate dagli errori \func{EINTR} e
-\func{EAGAIN} non sono errori. La prima si verifica quando la \func{read} è
+In realtà anche le due condizioni segnalate dagli errori \macro{EINTR} e
+\macro{EAGAIN} non sono errori. La prima si verifica quando la \func{read} è

 bloccata in attesa di dati in ingresso e viene interrotta da un segnale; in
 tal caso l'azione da prendere è quella di rieseguire la funzione. Torneremo
 sull'argomento in \secref{sec:signal_xxx}. 
 bloccata in attesa di dati in ingresso e viene interrotta da un segnale; in
 tal caso l'azione da prendere è quella di rieseguire la funzione. Torneremo
 sull'argomento in \secref{sec:signal_xxx}. 


@@ -915,7 +915,7 @@ La duplicazione dei file descriptor pu
 funzione di controllo dei file \func{fnctl} (che esamineremo in
 \secref{sec:file_fcntl}) con il parametro \macro{F\_DUPFD}. 
 
 funzione di controllo dei file \func{fnctl} (che esamineremo in
 \secref{sec:file_fcntl}) con il parametro \macro{F\_DUPFD}. 
 

-L'operazione ha la sintassi \func{fnctl(oldfd, F\_DUPFD, newfd)} e se si usa 0
+L'operazione ha la sintassi \code{fnctl(oldfd, F\_DUPFD, newfd)} e se si usa 0

 come valore per \param{newfd} diventa equivalente a \func{dup}. La sola
 differenza, a parte i codici di errore, è che \func{dup2} chiude il nuovo file
 se è già aperto mentre \func{fcntl} apre il primo disponibile con un valore
 come valore per \param{newfd} diventa equivalente a \func{dup}. La sola
 differenza, a parte i codici di errore, è che \func{dup2} chiude il nuovo file
 se è già aperto mentre \func{fcntl} apre il primo disponibile con un valore

diff --git a/gapil.tex b/gapil.tex
index 916b47b263a7254d285c64168b200225a726735c..053bc85d3eb76a8e4fa4f6554561c2f577405ab8 100644 (file)
--- a/gapil.tex
+++ b/gapil.tex
@@ -8,6 +8,7 @@
 \documentclass[a4paper,11pt,twoside,italian]{book}
 \usepackage[latin1]{inputenc}
 \usepackage[bookmarks=true]{hyperref}
 \documentclass[a4paper,11pt,twoside,italian]{book}
 \usepackage[latin1]{inputenc}
 \usepackage[bookmarks=true]{hyperref}

+\usepackage{makeidx}

 \usepackage{booktabs}
 \usepackage{pstcol}
 \usepackage{pst-node}
 \usepackage{booktabs}
 \usepackage{pstcol}
 \usepackage{pst-node}


@@ -45,6 +46,8 @@
 
 \author{Simone Piccardi}
 
 
 \author{Simone Piccardi}
 

+\makeindex
+

 \begin{document}
 
 \pagenumbering{roman}
 \begin{document}
 
 \pagenumbering{roman}


@@ -128,5 +131,7 @@
 
 %\bibliographystyle{phaip}
 %\bibliography{biblio}
 
 %\bibliographystyle{phaip}
 %\bibliography{biblio}

+\printindex
+
+\end{document}

 
 

-\end{document}
\ No newline at end of file

diff --git a/intro.tex b/intro.tex
index e50e8b9efe4c0e518e6487d569015a527fd91dce..d6e2a45cb271e541086181f8fba6eaf9eda6ad20 100644 (file)
--- a/intro.tex
+++ b/intro.tex
@@ -379,8 +379,8 @@ della AT/T.
 
 Benchè BSD non sia uno standard formalizzato, l'implementazione di unix
 dell'Università di Berkley, ha provveduto nel tempo una serie di estensioni e
 
 Benchè BSD non sia uno standard formalizzato, l'implementazione di unix
 dell'Università di Berkley, ha provveduto nel tempo una serie di estensioni e

-di API grande rilievo, come il link simbolici (vedi \secref{sec:file_symlink},
-la funzione \func{select}, i socket.
+di API grande rilievo, come il link simbolici, la funzione \code{select}, i
+socket.

 
 Queste estensioni sono state via via aggiunte al sistema nelle varie versioni
 del sistema (BSD 4.2, BSD 4.3 e BSD 4.4) come pure in alcuni derivati
 
 Queste estensioni sono state via via aggiunte al sistema nelle varie versioni
 del sistema (BSD 4.2, BSD 4.3 e BSD 4.4) come pure in alcuni derivati

diff --git a/macro.tex b/macro.tex
index 842859c3196879458b2118856203ab829307974f..7045267550ab6719ded827abc0565514e6824f6d 100644 (file)
--- a/macro.tex
+++ b/macro.tex
@@ -119,7 +119,10 @@ tab.~\thechapter.\theusercount}
 % variables, macros,  and everything can be useul, 
 %
 \newcommand{\cmd}[1]{\texttt{#1}}     % shell command
 % variables, macros,  and everything can be useul, 
 %
 \newcommand{\cmd}[1]{\texttt{#1}}     % shell command

-\newcommand{\func}[1]{\texttt{#1}}    % library function (or system call)
+\newcommand{\code}[1]{\texttt{#1}}    % for simple code
+\newcommand{\func}[1]{%
+\index{\texttt{#1}}\texttt{#1}%
+}                                     % library function (or system call)

 \newcommand{\macro}[1]{\texttt{#1}}   % macro constant
 \newcommand{\var}[1]{\texttt{#1}}     % variable 
 \newcommand{\file}[1]{\texttt{#1}}    % file name
 \newcommand{\macro}[1]{\texttt{#1}}   % macro constant
 \newcommand{\var}[1]{\texttt{#1}}     % variable 
 \newcommand{\file}[1]{\texttt{#1}}    % file name

diff --git a/process.tex b/process.tex
index f616206895875a0483c740447ed167e6f10f8def..b092b2d2faed477337d60b1641fa8c8d93883131 100644 (file)
--- a/process.tex
+++ b/process.tex
@@ -179,7 +179,7 @@ pu
 \end{prototype}
 \noindent la funzione richiede come argomento l'indirizzo della opportuna
 funzione di pulizia da chiamare all'uscita, che non deve prendere argomenti e
 \end{prototype}
 \noindent la funzione richiede come argomento l'indirizzo della opportuna
 funzione di pulizia da chiamare all'uscita, che non deve prendere argomenti e

-non deve ritornare niente (deve essere essere cioè definita come \func{void
+non deve ritornare niente (deve essere essere cioè definita come \code{void

   function(void)}).
 
 Una estensione di \func{atexit} è la funzione \func{on\_exit}, che le
   function(void)}).
 
 Una estensione di \func{atexit} è la funzione \func{on\_exit}, che le


@@ -841,7 +841,7 @@ ed \cmd{-m} e la prima vuole un parametro mentre la seconda no
 \cmd{-m}).
 
 Per gestire le opzioni all'interno dei argomenti a linea di comando passati in
 \cmd{-m}).
 
 Per gestire le opzioni all'interno dei argomenti a linea di comando passati in

-\func{argv} le librerie standard del C forniscono la funzione \func{getopt}
+\var{argv} le librerie standard del C forniscono la funzione \func{getopt}

 che ha il seguente prototipo:
 \begin{prototype}{unistd.h}
 {int getopt(int argc, char * const argv[], const char * optstring)}
 che ha il seguente prototipo:
 \begin{prototype}{unistd.h}
 {int getopt(int argc, char * const argv[], const char * optstring)}


@@ -912,9 +912,9 @@ elementi di \var{argv} che cominciano con il carattere \texttt{'-'}.
 
 Quando la funzione trova un'opzione essa ritorna il valore numerico del
 carattere, in questo modo si possono eseguire azioni specifiche usando uno
 
 Quando la funzione trova un'opzione essa ritorna il valore numerico del
 carattere, in questo modo si possono eseguire azioni specifiche usando uno

-\func{switch}; \func{getopt} inoltre inizializza alcune variabili globali:
+\code{switch}; \func{getopt} inoltre inizializza alcune variabili globali:

 \begin{itemize*}
 \begin{itemize*}

-\item \var{char * optarg} contiene il puntatore alla stringa parametro
+\item \var{char *optarg} contiene il puntatore alla stringa parametro

   dell'opzione.
 \item \var{int optind} alla fine della scansione restituisce l'indice del
   primo elemento di \var{argv} che non è un'opzione.
   dell'opzione.
 \item \var{int optind} alla fine della scansione restituisce l'indice del
   primo elemento di \var{argv} che non è un'opzione.


@@ -1128,7 +1128,7 @@ La seconda funzione prende come parametro una stringa analoga quella
 restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
 variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
 invece esiste il suo valore sarà settato a quello specificato da
 restituita da \func{getenv}, e sempre nella forma \var{NOME=valore}. Se la
 variabile specificata non esiste la stringa sarà aggiunta all'ambiente, se
 invece esiste il suo valore sarà settato a quello specificato da

-\func{string}. Si tenga presente che, seguendo lo standard SUSv2, le
+\param{string}. Si tenga presente che, seguendo lo standard SUSv2, le

 \acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
   comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
   \acr{glibc}, dalla versione 2.0 alla 2.1.1, veniva invece fatta una copia,
 \acr{glibc} successive alla versione 2.1.2 aggiungono\footnote{il
   comportamento è lo stesso delle vecchie \acr{libc4} e \acr{libc5}; nelle
   \acr{glibc}, dalla versione 2.0 alla 2.1.1, veniva invece fatta una copia,


@@ -1143,7 +1143,7 @@ questa funzione una variabile automatica (per evitare i problemi esposti in
 
 Si tenga infine presente che se si passa a \func{putenv} solo il nome di una
 variabile (cioè \param{string} è nella forma \texttt{NAME} e non contiene un
 
 Si tenga infine presente che se si passa a \func{putenv} solo il nome di una
 variabile (cioè \param{string} è nella forma \texttt{NAME} e non contiene un

-\var{=}) allora questa viene cancellata dall'ambiente. Infine se la chiamata
+\texttt{=}) allora questa viene cancellata dall'ambiente. Infine se la chiamata

 di \func{putenv} comporta la necessità di allocare una nuova versione del
 vettore \var{environ} questo sarà allocato, ma la versione corrente sarà
 deallocata solo se anch'essa è risultante da una allocazione fatta in
 di \func{putenv} comporta la necessità di allocare una nuova versione del
 vettore \var{environ} questo sarà allocato, ma la versione corrente sarà
 deallocata solo se anch'essa è risultante da una allocazione fatta in


@@ -1383,7 +1383,7 @@ dinamicamente con una delle funzioni della famiglia \func{malloc}.
 
 Il controllo del flusso di un programma in genere viene effettuato con le
 varie istruzioni del linguaggio C, la più bistrattata delle quali è il
 
 Il controllo del flusso di un programma in genere viene effettuato con le
 varie istruzioni del linguaggio C, la più bistrattata delle quali è il

-\func{goto}, ampiamente deprecato in favore di costrutti più puliti; esiste
+\code{goto}, ampiamente deprecato in favore di costrutti più puliti; esiste

 però un caso in l'uso di questa istruzione porta all'implementazione più
 efficiente, quello dell'uscita in caso di errore.
 
 però un caso in l'uso di questa istruzione porta all'implementazione più
 efficiente, quello dell'uscita in caso di errore.
 

diff --git a/prochand.tex b/prochand.tex
index e50895c68b5c0cb2bf6419854b9481370ca82c69..7a7bef4ed98671626d36f22576cda6ceb15d57c5 100644 (file)
--- a/prochand.tex
+++ b/prochand.tex
@@ -965,10 +965,11 @@ accessibili definendo la costante \macro{\_USE\_BSD}, sono:
   \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage
     * rusage)} 
   È identica a \func{waitpid} sia per comportamento che per i
   \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage
     * rusage)} 
   È identica a \func{waitpid} sia per comportamento che per i

-  valori dei parametri, ma restituisce in \var{rusage} un sommario delle
+  valori dei parametri, ma restituisce in \param{rusage} un sommario delle

   risorse usate dal processo (per i dettagli vedi \secref{sec:sys_xxx})
   risorse usate dal processo (per i dettagli vedi \secref{sec:sys_xxx})

+

   \funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)}
   \funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)}

-  Prima versione, equivalente a \func{wait4(-1, \&status, opt, rusage)} è
+  Prima versione, equivalente a \code{wait4(-1, \&status, opt, rusage)} è

   ormai deprecata in favore di \func{wait4}.
 \end{functions}
 \noindent 
   ormai deprecata in favore di \func{wait4}.
 \end{functions}
 \noindent 


@@ -1064,7 +1065,7 @@ e come ambiente la lista di stringhe indicata da \var{envp}; entrambe le
 liste devono essere terminate da un puntatore nullo. I vettori degli
 argomenti e dell'ambiente possono essere acceduti dal nuovo programma
 quando la sua funzione \func{main} è dichiarata nella forma
 liste devono essere terminate da un puntatore nullo. I vettori degli
 argomenti e dell'ambiente possono essere acceduti dal nuovo programma
 quando la sua funzione \func{main} è dichiarata nella forma

-\func{main(int argc, char *argv[], char *envp[])}.
+\code{main(int argc, char *argv[], char *envp[])}.

 
 Le altre funzioni della famiglia servono per fornire all'utente una serie
 possibile di diverse interfacce per la creazione di un nuovo processo. I loro
 
 Le altre funzioni della famiglia servono per fornire all'utente una serie
 possibile di diverse interfacce per la creazione di un nuovo processo. I loro


@@ -1093,7 +1094,7 @@ le modalit
 argomenti a linea di comando (cioè i valori di \var{argv} e \var{argc} visti
 dalla funzione \func{main} del programma chiamato). 
 
 argomenti a linea di comando (cioè i valori di \var{argv} e \var{argc} visti
 dalla funzione \func{main} del programma chiamato). 
 

-Queste modalità sono due e sono riassunte dagli mnenonici \func{v} e \func{l}
+Queste modalità sono due e sono riassunte dagli mnenonici \code{v} e \code{l}

 che stanno rispettivamente per \textit{vector} e \textit{list}. Nel primo caso
 gli argomenti sono passati tramite il vettore di puntatori \var{argv[]} a
 stringhe terminate con zero che costituiranno gli argomenti a riga di comando,
 che stanno rispettivamente per \textit{vector} e \textit{list}. Nel primo caso
 gli argomenti sono passati tramite il vettore di puntatori \var{argv[]} a
 stringhe terminate con zero che costituiranno gli argomenti a riga di comando,


@@ -1136,7 +1137,7 @@ per indicare il nome del file che contiene il programma che verr
 \end{table}
 
 La seconda differenza fra le funzioni riguarda le modalità con cui si
 \end{table}
 
 La seconda differenza fra le funzioni riguarda le modalità con cui si

-specifica il programma che si vuole eseguire. Con lo mnemonico \func{p} si
+specifica il programma che si vuole eseguire. Con lo mnemonico \code{p} si

 indicano le due funzioni che replicano il comportamento della shell nello
 specificare il comando da eseguire; quando il parametro \var{file} non
 contiene una \file{/} esso viene considerato come un nome di programma, e
 indicano le due funzioni che replicano il comportamento della shell nello
 specificare il comando da eseguire; quando il parametro \var{file} non
 contiene una \file{/} esso viene considerato come un nome di programma, e


@@ -1160,7 +1161,7 @@ indicato dal parametro \var{path}, che viene interpretato come il
 \end{figure}
 
 La terza differenza è come viene passata la lista delle variabili di ambiente.
 \end{figure}
 
 La terza differenza è come viene passata la lista delle variabili di ambiente.

-Con lo mnemonico \func{e} vengono indicate quelle funzioni che necessitano di
+Con lo mnemonico \code{e} vengono indicate quelle funzioni che necessitano di

 un vettore di parametri \var{envp[]} analogo a quello usato per gli argomenti
 a riga di comando (terminato quindi da un \macro{NULL}), le altre usano il
 valore della variabile \var{environ} (vedi \secref{sec:proc_environ}) del
 un vettore di parametri \var{envp[]} analogo a quello usato per gli argomenti
 a riga di comando (terminato quindi da un \macro{NULL}), le altre usano il
 valore della variabile \var{environ} (vedi \secref{sec:proc_environ}) del


@@ -1473,7 +1474,7 @@ situazione degli identificatori 
 \end{eqnarray*}
 in questo modo, dato che l'\textit{effective group id} è quello giusto, il
 programma può accedere a \file{/var/log/utmp} in scrittura ed aggiornarlo, a
 \end{eqnarray*}
 in questo modo, dato che l'\textit{effective group id} è quello giusto, il
 programma può accedere a \file{/var/log/utmp} in scrittura ed aggiornarlo, a

-questo punto il programma può eseguire una \func{setgid(getgid())} per settare
+questo punto il programma può eseguire una \code{setgid(getgid())} per settare

 l'\textit{effective group id} a quello dell'utente (e dato che il \textit{real
   group id} corrisponde la funzione avrà successo), in questo modo non sarà
 possibile lanciare dal terminale programmi che modificano detto file, in tal
 l'\textit{effective group id} a quello dell'utente (e dato che il \textit{real
   group id} corrisponde la funzione avrà successo), in questo modo non sarà
 possibile lanciare dal terminale programmi che modificano detto file, in tal


@@ -1487,7 +1488,7 @@ caso infatti la situazione degli identificatori sarebbe:
 e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
 \textit{effective group id}. All'uscita dal terminale, per poter di nuovo
 aggiornare lo stato di \file{/var/log/utmp} il programma eseguirà una
 e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
 \textit{effective group id}. All'uscita dal terminale, per poter di nuovo
 aggiornare lo stato di \file{/var/log/utmp} il programma eseguirà una

-\func{setgid(utmp)} (dove \var{utmp} è il valore numerico associato al gruppo
+\code{setgid(utmp)} (dove \var{utmp} è il valore numerico associato al gruppo

 \acr{utmp}, ottenuto ad esempio con una \func{getegid}), dato che in questo
 caso il valore richiesto corrisponde al \textit{saved group id} la funzione
 avrà successo e riporterà la situazione a:
 \acr{utmp}, ottenuto ad esempio con una \func{getegid}), dato che in questo
 caso il valore richiesto corrisponde al \textit{saved group id} la funzione
 avrà successo e riporterà la situazione a:


@@ -1808,7 +1809,7 @@ esempio utilizzano variabili statiche, le \acr{glibc} per
 disposizione due macro di compilatore, \macro{\_REENTRANT} e
 \macro{\_THREAD\_SAFE}, la cui definizione attiva le versioni rientranti di
 varie funzioni di libreria, che sono identificate aggiungendo il suffisso
 disposizione due macro di compilatore, \macro{\_REENTRANT} e
 \macro{\_THREAD\_SAFE}, la cui definizione attiva le versioni rientranti di
 varie funzioni di libreria, che sono identificate aggiungendo il suffisso

-\func{\_r} al nome della versione normale.
+\code{\_r} al nome della versione normale.

 
 
 
 
 
 

diff --git a/signal.tex b/signal.tex
index 072b1d1edeaf638aef100fa2e141f3b3b5c7892c..e67985bc2fdc42b902f632e35f34911e76ec1120 100644 (file)
--- a/signal.tex
+++ b/signal.tex
@@ -124,7 +124,7 @@ riprende l'esecuzione all'istruzione successiva, ma essendo cambiato il flag
 la condizione non è più soddisfatta e il programma prosegue.
 
 Il problema con l'implementazione inaffidabile è che niente ci garantisce che
 la condizione non è più soddisfatta e il programma prosegue.
 
 Il problema con l'implementazione inaffidabile è che niente ci garantisce che

-il segnale arrivi fra la valutazione della condizione del \func{while} e la
+il segnale arrivi fra la valutazione della condizione del \code{while} e la

 chiamata a \func{pause}, nel qual caso, se il segnale non viene più generato,
 il processo resterà in sleep permanentemente.
 
 chiamata a \func{pause}, nel qual caso, se il segnale non viene più generato,
 il processo resterà in sleep permanentemente.
 


@@ -655,24 +655,39 @@ classificabili in maniera omogenea. Questi segnali sono:
 \subsection{Le funzioni \func{strsignal} e \func{psignal}}
 \label{sec:sig_strsignal}
 
 \subsection{Le funzioni \func{strsignal} e \func{psignal}}
 \label{sec:sig_strsignal}
 

-Per la descrizione dei segnali il sistema mette a disposizione due funzioni
-che stampano un messaggio di descrizione dato il numero. In genere si usano
-quando si vuole notificare all'utente il segnale avvenuto (nel caso di
-terminazione di un processo figlio o di un manipolatore che gestisce più
-segnali); la prima funzione è una estensione GNU ed è analoga alla funzione
-\func{strerr} per gli errori:
-\begin{prototype}{string.h}{char * strsignal (int signum)} 
-  Ritorna il puntatore ad una stringa allocata staticamente che contiene la
-  descrizione del segnale \var{signum}. 
+Per la descrizione dei segnali il sistema mette a disposizione due funzioni,
+\func{strsignal} e \func{psignal}, che stampano un messaggio di descrizione
+dato il numero. In genere si usano quando si vuole notificare all'utente il
+segnale avvenuto (nel caso di terminazione di un processo figlio o di un
+manipolatore che gestisce più segnali); la prima funzione è una estensione
+GNU, accessibile avendo definito \macro{\_GNU\_SOURCE}, ed è analoga alla
+funzione \func{strerror} (si veda \secref{sec:sys_strerror}) per gli errori:
+\begin{prototype}{string.h}{char *strsignal(int signum)} 
+  Ritorna il puntatore ad una stringa che contiene la descrizione del segnale
+  \var{signum}.

 \end{prototype}
 \end{prototype}

-
-Dato che la stringa è allocata staticamente non se ne deve modificare il
-contenuto, che resta valido solo fino alla successiva chiamata di
-\func{strsignal}; nel caso si debba mantenere traccia del messaggio sarà
+\noindent dato che la stringa è allocata staticamente non se ne deve
+modificare il contenuto, che resta valido solo fino alla successiva chiamata
+di \func{strsignal}. Nel caso si debba mantenere traccia del messaggio sarà

 necessario copiarlo.
 
 La seconda funzione deriva da BSD ed è analoga alla funzione \func{perror}
 necessario copiarlo.
 
 La seconda funzione deriva da BSD ed è analoga alla funzione \func{perror}

-descritta in \secref{sec:sys_strerror}.
+descritta in \secref{sec:sys_strerror}; il suo prototipo è:
+\begin{prototype}{signal.h}{void psignal(int sig, const char *s)} 
+  Stampa sullo standard error un messaggio costituito dalla stringa \param{s},
+  seguita da due punti ed una descrizione del segnale indicato da \param{sig}.
+\end{prototype}
+
+Una modalità alternativa per utilizzare le descrizioni restituite da
+\func{strsignal} e \func{psignal} è quello di fare usare la variabile
+\var{sys\_siglist}, che può essere acceduta dichiarando:
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+    extern const char *const sys_siglist[]
+\end{lstlisting}
+\var{sys\_siglist} contiene le stringhe di descrizione indicizzate per numero
+di segnale, per cui \code{char *decr = strsignal(SIGINT)} può essere
+sostituito dall'equivalente \code{char *decr = sys\_siglist[SIGINT]}.
+

 
 
 \section{La gestione dei segnali}
 
 
 \section{La gestione dei segnali}


@@ -713,7 +728,7 @@ comportamento, pur mantenendone immutato il prototipo\footnote{in realt
 
 In questa definizione si è usato il tipo \type{sighandler\_t} che è una
 estensione GNU definita in Linux che permette di riscrivere il prototipo in
 
 In questa definizione si è usato il tipo \type{sighandler\_t} che è una
 estensione GNU definita in Linux che permette di riscrivere il prototipo in

-forma più leggibile dell'originario \func{void (*signal(int signum, void
+forma più leggibile dell'originario \code{void (*signal(int signum, void

   (*handler)(int)))int)}, e che è sostanzialmente equivalente alla
 definizione:
 \begin{verbatim}
   (*handler)(int)))int)}, e che è sostanzialmente equivalente alla
 definizione:
 \begin{verbatim}

diff --git a/simpltcp.tex b/simpltcp.tex
index e592f2f634978b84ad570d8beb44d43cd59fcf71..f7260cff817454a95a9cb9d550109a9d2c0c75df 100644 (file)
--- a/simpltcp.tex
+++ b/simpltcp.tex
@@ -44,7 +44,7 @@ una implementazione completa.
 \label{sec:TCPsimp_server_main}
 
 La prima versione del server, \file{ElemEchoTCPServer.c}, si compone di un
 \label{sec:TCPsimp_server_main}
 
 La prima versione del server, \file{ElemEchoTCPServer.c}, si compone di un

-corpo principale, costituito dalla funzione \func{main}.  Questa si incarica
+corpo principale, costituito dalla funzione \code{main}.  Questa si incarica

 di creare il socket, metterlo in ascolto di connessioni in arrivo e creare un
 processo figlio a cui delegare la gestione di ciascuna connessione.  Questa
 parte, riportata in \nfig, è analoga a quella vista nel precedente esempio
 di creare il socket, metterlo in ascolto di connessioni in arrivo e creare un
 processo figlio a cui delegare la gestione di ciascuna connessione.  Questa
 parte, riportata in \nfig, è analoga a quella vista nel precedente esempio


@@ -106,7 +106,7 @@ int main(int argc, char *argv[])
     exit(0);
 }
   \end{lstlisting}
     exit(0);
 }
   \end{lstlisting}

-  \caption{Codice della funzione \texttt{main} della prima versione del server
+  \caption{Codice della funzione \code{main} della prima versione del server

     per il servizio \texttt{echo}.}
   \label{fig:TCPsimpl_serv_code}
 \end{figure}
     per il servizio \texttt{echo}.}
   \label{fig:TCPsimpl_serv_code}
 \end{figure}


@@ -116,12 +116,12 @@ quella dell'esempio citato, ed ad esso si applicano le considerazioni fatte in
 \secref{sec:TCPel_cunc_daytime}. Le uniche differenze rispetto all'esempio in
 \figref{fig:TCPel_serv_code} sono che in questo caso per il socket in
 ascolto viene usata la porta 7 e tutta la gestione della comunicazione è
 \secref{sec:TCPel_cunc_daytime}. Le uniche differenze rispetto all'esempio in
 \figref{fig:TCPel_serv_code} sono che in questo caso per il socket in
 ascolto viene usata la porta 7 e tutta la gestione della comunicazione è

-delegata alla funzione \func{ServEcho}.
+delegata alla funzione \code{ServEcho}.

 %  Per ogni connessione viene creato un
 % processo figlio, il quale si incarica di lanciare la funzione
 % \texttt{SockEcho}.
 
 %  Per ogni connessione viene creato un
 % processo figlio, il quale si incarica di lanciare la funzione
 % \texttt{SockEcho}.
 

-Il codice della funzione \func{ServEcho} è invece mostrata in \nfig, la
+Il codice della funzione \code{ServEcho} è invece mostrata in \nfig, la

 comunicazione viene gestita all'interno del ciclo (linee \texttt{\small
   6--8}).  I dati inviati dal client vengono letti dal socket con una semplice
 \func{read} (che ritorna solo in presenza di dati in arrivo), la riscrittura
 comunicazione viene gestita all'interno del ciclo (linee \texttt{\small
   6--8}).  I dati inviati dal client vengono letti dal socket con una semplice
 \func{read} (che ritorna solo in presenza di dati in arrivo), la riscrittura


@@ -145,7 +145,7 @@ void ServEcho(int sockfd) {
     return;
 }
   \end{lstlisting}
     return;
 }
   \end{lstlisting}

-  \caption{Codice della prima versione della funzione \func{ServEcho} per la
+  \caption{Codice della prima versione della funzione \code{ServEcho} per la

     gestione del servizio \texttt{echo}.}
   \label{fig:TCPsimpl_server_elem_sub}
 \end{figure}
     gestione del servizio \texttt{echo}.}
   \label{fig:TCPsimpl_server_elem_sub}
 \end{figure}


@@ -204,14 +204,14 @@ int main(int argc, char *argv[])
   \label{fig:TCPsimpl_client_elem}
 \end{figure}
 
   \label{fig:TCPsimpl_client_elem}
 \end{figure}
 

-La funzione \func{main} si occupa della creazione del socket e della
+La funzione \code{main} si occupa della creazione del socket e della

 connessione (linee \texttt{\small 10--27}) secondo la stessa modalità spiegata
 in \secref{sec:net_cli_sample}, il client si connette sulla porta 7
 all'indirizzo specificato dalla linea di comando (a cui si è aggiunta una
 elementare gestione delle opzioni non riportata in figura).
 
 Completata la connessione (quando la funzione \func{connect} ritorna) la
 connessione (linee \texttt{\small 10--27}) secondo la stessa modalità spiegata
 in \secref{sec:net_cli_sample}, il client si connette sulla porta 7
 all'indirizzo specificato dalla linea di comando (a cui si è aggiunta una
 elementare gestione delle opzioni non riportata in figura).
 
 Completata la connessione (quando la funzione \func{connect} ritorna) la

-funzione \func{ClientEcho}, riportata in \nfig, si preoccupa di gestire la
+funzione \code{ClientEcho}, riportata in \nfig, si preoccupa di gestire la

 comunicazione, leggendo una riga alla volta dallo \file{stdin}, scrivendola
 sul socket e ristampando su \file{stdout} quanto ricevuto in risposta dal
 server. 
 comunicazione, leggendo una riga alla volta dallo \file{stdin}, scrivendola
 sul socket e ristampando su \file{stdout} quanto ricevuto in risposta dal
 server. 


@@ -240,9 +240,9 @@ void ClientEcho(FILE * filein, int socket)
 La funzione utilizza due buffer per gestire i dati inviati e letti sul socket
 (\texttt{\small 3}).  La comunicazione viene gestita all'interno di un ciclo
 (linee \texttt{\small 5--10}), i dati da inviare sulla connessione vengono
 La funzione utilizza due buffer per gestire i dati inviati e letti sul socket
 (\texttt{\small 3}).  La comunicazione viene gestita all'interno di un ciclo
 (linee \texttt{\small 5--10}), i dati da inviare sulla connessione vengono

-presi dallo \texttt{stdin} usando la funzione \func{fgets} che legge una
+presi dallo \file{stdin} usando la funzione \func{fgets} che legge una

 linea di testo (terminata da un \texttt{CR} e fino al massimo di
 linea di testo (terminata da un \texttt{CR} e fino al massimo di

-\texttt{MAXLINE} caratteri) e la salva sul buffer di invio, la funzione
+\macro{MAXLINE} caratteri) e la salva sul buffer di invio, la funzione

 \func{SockWrite} (\texttt{\small 3}) scrive detti dati sul socket (gestendo
 l'invio multiplo qualora una singola \func{write} non basti, come spiegato
 in \secref{sec:sock_io_behav}).
 \func{SockWrite} (\texttt{\small 3}) scrive detti dati sul socket (gestendo
 l'invio multiplo qualora una singola \func{write} non basti, come spiegato
 in \secref{sec:sock_io_behav}).


@@ -307,10 +307,10 @@ tcp        0      0 roke:echo               gont:32981              ESTABLISHED
 \end{verbatim}
 mentre per quanto riguarda l'esecuzione dei programmi avremo che:
 \begin{itemize}
 \end{verbatim}
 mentre per quanto riguarda l'esecuzione dei programmi avremo che:
 \begin{itemize}

-\item il client chiama la funzione \func{ClientEcho} che si blocca sulla
+\item il client chiama la funzione \code{ClientEcho} che si blocca sulla

   \func{fgets} dato che non si è ancora scritto nulla sul terminale.
 \item il server eseguirà una \func{fork} facendo chiamare al processo figlio
   \func{fgets} dato che non si è ancora scritto nulla sul terminale.
 \item il server eseguirà una \func{fork} facendo chiamare al processo figlio

-  la funzione \func{ServEcho}, quest'ultima si bloccherà sulla \func{read}
+  la funzione \code{ServEcho}, quest'ultima si bloccherà sulla \func{read}

   dal socket sul quale ancora non sono presenti dati.
 \item il processo padre del server chiamerà di nuovo \func{accept}
   bloccandosi fino all'arrivo di un'altra connessione.
   dal socket sul quale ancora non sono presenti dati.
 \item il processo padre del server chiamerà di nuovo \func{accept}
   bloccandosi fino all'arrivo di un'altra connessione.


@@ -357,7 +357,7 @@ punto avremo:
 tcp        0      0 *:echo                  *:*                     LISTEN
 tcp        0      0 localhost:33032         localhost:echo          TIME_WAIT
 \end{verbatim} %$
 tcp        0      0 *:echo                  *:*                     LISTEN
 tcp        0      0 localhost:33032         localhost:echo          TIME_WAIT
 \end{verbatim} %$

-con il client che entra in \macro{TIME\_WAIT}.
+con il client che entra in \texttt{TIME\_WAIT}.

 
 Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
 terminazione normale della connessione, che ci servirà poi da riferimento nei
 
 Esaminiamo allora in dettaglio la sequenza di eventi che porta alla
 terminazione normale della connessione, che ci servirà poi da riferimento nei


@@ -366,24 +366,24 @@ casi seguenti:
 \begin{enumerate}
 \item inviando un carattere di EOF da terminale la \func{fgets} ritorna
   restituendo un puntatore nullo che causa l'uscita dal ciclo di
 \begin{enumerate}
 \item inviando un carattere di EOF da terminale la \func{fgets} ritorna
   restituendo un puntatore nullo che causa l'uscita dal ciclo di

-  while, così la \func{ClientEcho} ritorna.
-\item al ritorno di \func{ClientEcho} ritorna anche la funzione \func{main}, e
+  while, così la \code{ClientEcho} ritorna.
+\item al ritorno di \code{ClientEcho} ritorna anche la funzione \code{main}, e

   come parte del processo terminazione tutti i file descriptor vengono chiusi
   (si ricordi quanto detto in \secref{sec:proc_term_conclusion}); questo causa
   la chiusura del socket di comunicazione; il client allora invierà un FIN al
   server a cui questo risponderà con un ACK.  A questo punto il client verrà a
   come parte del processo terminazione tutti i file descriptor vengono chiusi
   (si ricordi quanto detto in \secref{sec:proc_term_conclusion}); questo causa
   la chiusura del socket di comunicazione; il client allora invierà un FIN al
   server a cui questo risponderà con un ACK.  A questo punto il client verrà a

-  trovarsi nello stato \macro{FIN\_WAIT\_2} ed il server nello stato
-  \macro{CLOSE\_WAIT} (si riveda quanto spiegato in
+  trovarsi nello stato \texttt{FIN\_WAIT\_2} ed il server nello stato
+  \texttt{CLOSE\_WAIT} (si riveda quanto spiegato in

   \secref{sec:TCPel_conn_term}).
 \item quando il server riceve il FIN la \func{read} del processo figlio che
   gestisce la connessione ritorna restituendo 0 causando così l'uscita dal
   \secref{sec:TCPel_conn_term}).
 \item quando il server riceve il FIN la \func{read} del processo figlio che
   gestisce la connessione ritorna restituendo 0 causando così l'uscita dal

-  ciclo di while e il ritorno di \func{ServEcho}, a questo punto il processo
+  ciclo di while e il ritorno di \code{ServEcho}, a questo punto il processo

   figlio termina chiamando \func{exit}.
 \item all'uscita del figlio tutti i file descriptor vengono chiusi, la
   chiusura del socket connesso fa sì che venga effettuata la sequenza finale
   di chiusura della connessione, viene emesso un FIN dal server che riceverà
   un ACK dal client, a questo punto la connessione è conclusa e il client
   figlio termina chiamando \func{exit}.
 \item all'uscita del figlio tutti i file descriptor vengono chiusi, la
   chiusura del socket connesso fa sì che venga effettuata la sequenza finale
   di chiusura della connessione, viene emesso un FIN dal server che riceverà
   un ACK dal client, a questo punto la connessione è conclusa e il client

-  resta nello stato \func{TIME\_WAIT}.
+  resta nello stato \texttt{TIME\_WAIT}.

 \item 
 \end{enumerate}
 
 \item 
 \end{enumerate}
 

diff --git a/socket.tex b/socket.tex
index ec886642980345b4071c4e98372e551ebd017aa7..f38305ae5a17ed1a9de53941cbbbe7531a7c05a5 100644 (file)
--- a/socket.tex
+++ b/socket.tex
@@ -601,11 +601,12 @@ funzioni sono:
   Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello
   della macchina.
 \end{prototype}
   Converte l'intero a 16 bit \var{netshort} dal formato della rete a quello
   della macchina.
 \end{prototype}

-I nomi sono assegnati usando la lettera \func{n} come mnemonico per indicare
+I nomi sono assegnati usando la lettera \texttt{n} come mnemonico per indicare

 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera
 l'ordinamento usato sulla rete (da \textit{network order}) e la lettera

-\func{h} come mnemonico per l'ordinamento usato sulla macchina locale (da
-\textit{host order}), mentre le lettere \func{s} e \func{l} stanno ad indicare
-i tipi di dato (\type{long} o \type{short}, riportati anche dai prototipi).
+\texttt{h} come mnemonico per l'ordinamento usato sulla macchina locale (da
+\textit{host order}), mentre le lettere \texttt{s} e \texttt{l} stanno ad
+indicare i tipi di dato (\type{long} o \type{short}, riportati anche dai
+prototipi).

 
 Usando queste funzioni si ha la conversione automatica: nel caso in cui la
 macchina che si sta usando abbia una architettura \textit{big endian} queste
 
 Usando queste funzioni si ha la conversione automatica: nel caso in cui la
 macchina che si sta usando abbia una architettura \textit{big endian} queste


@@ -626,7 +627,7 @@ Le prime tre funzioni di manipolazione riguardano la conversione degli
 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network
 indirizzi IPv4 da una stringa in cui il numero di IP è espresso secondo la
 cosiddetta notazione \textit{dotted-decimal}, (cioè nella forma
 \texttt{192.160.0.1}) al formato binario (direttamente in \textit{network

-  order}) e viceversa; in questo caso si usa la lettera \func{a} come
+  order}) e viceversa; in questo caso si usa la lettera \texttt{a} come

 mnemonico per indicare la stringa. Dette funzioni sono:
 \begin{prototype}{arpa/inet.h}
   {int inet\_aton(const char *src, struct in\_addr *dest)} 
 mnemonico per indicare la stringa. Dette funzioni sono:
 \begin{prototype}{arpa/inet.h}
   {int inet\_aton(const char *src, struct in\_addr *dest)} 


@@ -659,9 +660,9 @@ mnemonico per indicare la stringa. Dette funzioni sono:
 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
 motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e
 \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in
 Le tre funzioni precedenti sono limitate solo ad indirizzi IPv4, per questo
 motivo è preferibile usare le due nuove funzioni \func{inet\_pton} e
 \func{inet\_ntop} che possono convertire anche gli indirizzi IPv6. Anche in

-questo caso le lettere \func{n} e \func{p} sono degli mnemonici per ricordare
-il tipo di conversione effettuata e stanno per \textit{presentation} e
-\textit{numeric}.
+questo caso le lettere \texttt{n} e \texttt{p} sono degli mnemonici per
+ricordare il tipo di conversione effettuata e stanno per \textit{presentation}
+e \textit{numeric}.

 
 % \begin{figure}[htb]
 %   \centering  
 
 % \begin{figure}[htb]
 %   \centering  

diff --git a/system.tex b/system.tex
index 6410f1a2dd1241f976c6b456e5480fc983590e04..a1aa32fab1dfc0e55d2e7390685d60bf95b03822 100644 (file)
--- a/system.tex
+++ b/system.tex
@@ -43,13 +43,13 @@ definizioni:
   dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
   viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
   indicare le date di modifica dei file o quelle di avvio dei processi. Per
   dato che l'UTC corrisponde all'ora locale di Greenwich.  È il tempo su cui
   viene mantenuto l'orologio del calcolatore, e viene usato ad esempio per
   indicare le date di modifica dei file o quelle di avvio dei processi. Per

-  memorizzare questo tempo è stato riservato il tipo primitivo \func{time\_t}.
+  memorizzare questo tempo è stato riservato il tipo primitivo \type{time\_t}.

 \item \textit{process time}: talvolta anche detto tempo di CPU. Viene misurato
   in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
   dal timer di sistema, e che per Linux avvengono ogni centesimo di
   secondo\footnote{eccetto per la piattaforma alpha dove avvengono ogni
     millesimo di secondo}. Il dato primitivo usato per questo tempo è
 \item \textit{process time}: talvolta anche detto tempo di CPU. Viene misurato
   in \textit{clock tick}, corrispondenti al numero di interruzioni effettuate
   dal timer di sistema, e che per Linux avvengono ogni centesimo di
   secondo\footnote{eccetto per la piattaforma alpha dove avvengono ogni
     millesimo di secondo}. Il dato primitivo usato per questo tempo è

-  \func{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di
+  \type{clock\_t}, inoltre la costante \macro{HZ} restituisce la frequenza di

   operazione del timer, e corrisponde dunque al numero di tick al secondo.  Lo
   standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
   questo valore può comunque essere ottenuto con \func{sysconf} (vedi
   operazione del timer, e corrisponde dunque al numero di tick al secondo.  Lo
   standard POSIX definisce allo stesso modo la costante \macro{CLK\_TCK});
   questo valore può comunque essere ottenuto con \func{sysconf} (vedi


@@ -95,7 +95,7 @@ presenta una serie di problemi nel caso lo si debba usare con i thread.
 Esamineremo in questa sezione le sue caratteristiche principali.
 
 
 Esamineremo in questa sezione le sue caratteristiche principali.
 
 

-\subsection{La variabile \func{errno}}
+\subsection{La variabile \var{errno}}

 \label{sec:sys_errno}
 
 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
 \label{sec:sys_errno}
 
 Quasi tutte le funzioni delle librerie del C sono in grado di individuare e