Risistemazione di system.tex per aggiungere i riferimenti corretti al NSS,
authorSimone Piccardi <piccardi@gnulinux.it>
Sat, 3 Jul 2004 22:53:13 +0000 (22:53 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Sat, 3 Jul 2004 22:53:13 +0000 (22:53 +0000)
con riformattazione del capitolo. Scritto programma di test per
gethostbyname, e scritto qualcosa sul NSS nel capitolo del resolver

listati/rlimit.h
sockctrl.tex
sources/myhost.c [new file with mode: 0644]
system.tex

index f8628b8..0b7d797 100644 (file)
@@ -1,4 +1,5 @@
 struct rlimit {
-     rlim_t    rlim_cur;
-     rlim_t    rlim_max;
+     rlim_t    rlim_cur;    /* Soft limit */
+     rlim_t    rlim_max;    /* Hard limit (ceiling for rlim_cur) */
+
 };
index 24c752f..5efe128 100644 (file)
@@ -84,31 +84,95 @@ direttive che possono essere usate in questi file, che si trovano nelle
 relative pagine di manuale.
 
 Con il tempo però è divenuto possibile fornire diversi sostituti per
-l'utilizzo delle associazione statiche in \file{/etc/hosts}, inoltre oltre all
-risoluzione dei nomi a dominio si sono aggiunti altri nomi da risolvere, come
-quelli associati alle reti ed ai gruppi di macchine definiti dal servizio NIS,
-o quelli dei protocolli e dei servizi mantenuti nei file statici
-\file{/etc/protocols} e \file{/etc/services}, tutte informazioni che
-normalmente non si trovano su un DNS, ma che in un ambiente distribuito
+l'utilizzo delle associazione statiche in \file{/etc/hosts}, inoltre oltre
+alla risoluzione dei nomi a dominio ci sono anche altri nomi da risolvere,
+come quelli che possono essere associati ad una rete (invece che ad una
+singola macchina) o ai gruppi di macchine definiti dal servizio NIS, o come
+quelli dei protocolli e dei servizi che sono mantenuti nei file statici
+\file{/etc/protocols} e \file{/etc/services}. Tutte queste sono informazioni
+che normalmente non si trovano su un DNS, ma che in un ambiente distribuito
 possono essere centralizzate su opportuni server (ad esempio su LDAP) in grado
 di mantenerle.
 
+
+
+Il sistema del \textit{Name Service Switch} (cui faremo riferimento in seguito
+con l'acronimo NSS) è un sistema di librerie dinamiche che permette di
+definire in maniera generica sia i supporti su cui mantenere i dati di
+corrispondenza fra nomi e valori numerici, sia l'ordine in cui effettuare le
+ricerche sui vari supporti disponibili. Il sistema prevede una serie di
+possibili classi di corrispondenza, riportate in
+tab.~\ref{tab:sys_NSS_classes}.
+
+\begin{table}[htb]
+  \footnotesize
+  \centering
+  \begin{tabular}[c]{|l|p{8cm}|}
+    \hline
+    \textbf{Classe} & \textbf{Tipo di corrispondenza}\\
+    \hline
+    \hline
+    \texttt{shadow}   & corrispondenze fra username e proprietà dell'utente
+                       (\acr{uid}, ecc.).\\  
+    \texttt{group}    & corrispondenze fra nome del gruppo e proprietà dello 
+                        stesso.\\  
+    \texttt{aliases}  & alias per la posta elettronica\\ 
+    \texttt{ethers}   & corrispondenze fra numero IP e MAC address della
+                        scheda di rete.\\ 
+    \texttt{hosts}    & corrispondenze fra nome a dominio e numero IP.\\ 
+    \texttt{netgroup} & corrispondenze gruppo di rete e macchine che lo
+                        compongono.\\  
+    \texttt{networks} & corrispondenze fra nome di una rete e suo indirizzo
+                        IP.\\  
+    \texttt{protocols}& corrispondenze fra nome di un protocollo e relativo
+                        numero identificativo.\\ 
+    \texttt{rpc}      & corrispondenze fra nome di un servizio RPC e relativo 
+                        numero identificativo.\\ 
+    \texttt{services} & corrispondenze fra nome di un servizio e numero di
+                        porta. \\ 
+    \hline
+  \end{tabular}
+  \caption{Le diverse classi di corrispondenze definite
+    all'interno del \textit{Name Service Switch}.} 
+  \label{tab:sys_NSS_classes}
+\end{table}
+
+
+
 Questo ha portato alla creazione di un sistema di risoluzione più ampio, il
 \textit{Name Service Switch} di cui il \textit{resolver} viene a costituire un
-sottoinsieme. Questo sistema, che si applica anche alla risoluzioni fra nomi
-di utenti e gruppi e relativi identificatori, permette di definire in maniera
-generica (attraverso una serie di librerie dinamiche) sia i supporti su cui
-mantenere i dati di corrispondenza fra nomi e valori numerici, sia l'ordine in
-cui effettuare le ricerche sui vari supporti disponibili.  Il sistema è
+sottoinsieme. Questo sistema permette di definire in maniera generica
+(attraverso una serie di librerie dinamiche) sia i supporti su cui mantenere i
+dati di corrispondenza fra nomi e valori numerici, sia l'ordine in cui
+effettuare le ricerche sui vari supporti disponibili.  Il sistema è
 controllato dal file \file{/etc/nsswitch.conf}, ed anche per questo si può
 fare riferimento alle pagine di manuale ed al relativo capitolo nel manuale
 \cite{glibc} delle \textsl{glibc}.
 
+Il
+sistema è controllato dal file \file{/etc/nsswitch.conf}, ed anche per questo
+si può fare riferimento alle pagine di manuale ed al relativo capitolo nel
+manuale \cite{glibc} delle \textsl{glibc}.
+
+
+
+Per questo motivo anche il sistema del \textit{resolver} è stato poi incluso
+all'interno del sistema sistema di risoluzione più ampio costituito dal
+\textit{Name Service Switch} che abbiamo visto in
+sez.~\ref{sec:sys_user_group}, dove sono previste le funzionalità di controllo
+per la risoluzione anche di questo tipo di corrispondenze.  Questo significa
+allora, per quanto riguarda la risoluzione dei nomi a dominio, che oltre ai
+file che abbiamo appena illustrato, dovremo tenere in considerazione anche il
+contenuto del file \file{/etc/nsswitch.conf}.
+
 In ogni caso, qualunque sia la modalità con cui ricevono i dati o il supporto
-su cui vengono mantenuti, dal punto di vista di un programma che deve
-effettuare la risoluzione di un nome, tutto quello che conta sono le funzioni
-che il \textit{resolver} mette a disposizione, e sono queste quelle che
-tratteremo nelle sezioni successive.
+su cui vengono mantenuti, e che si usino o meno funzionalità aggiuntive
+fornire dal sistema del \textit{Name Service Switch}, dal punto di vista di un
+programma che deve effettuare la risoluzione di un nome, tutto quello che
+conta sono le funzioni che il \textit{resolver} mette a
+disposizione,\footnote{è cura della implementazione fattane nelle \acr{glibc}
+  tenere conto della presenza del \textit{Name Service Switch}.} e sono queste
+quelle che tratteremo nelle sezioni successive.
 
 
 
@@ -146,32 +210,33 @@ fallita.
   \begin{minipage}[c]{15cm}
     \includestruct{listati/hostent.h}
   \end{minipage}
-  \caption{La struttura \structd{hostent} .}
+  \caption{La struttura \structd{hostent}.}
   \label{fig:sock_hostent_struct}
 \end{figure}
 
 Per questo motivo all'interno del resolver è stata definita una apposita
 variabile di errore, \var{h\_errno} che viene utilizzata dalle funzioni di
 libreria per indicare quale problema ha causato il fallimento della
-risoluzione. Ad essa si può accedere una volta che la si dichiara con:
-\includecodesnip{listati/herrno.c}
+risoluzione del nome. Ad essa si può accedere una volta che la si dichiara
+con: 
+\includecodesnip{listati/herrno.c} 
 ed i valori che può assumere sono i seguenti:
 \begin{basedescript}{\desclabelwidth{3cm}\desclabelstyle{\nextlinelabel}}
 \item[\const{HOST\_NOT\_FOUND}] l'indirizzo richiesto non è valido e la
   macchina indicata è sconosciuta.
 \item[\const{NO\_ADDRESS}] il nome a dominio richiesto è valido, ma non ha un
-  indirizzo associato ad esso.
+  indirizzo associato ad esso (alternativamente può essere indicato come
+  \const{NO\_DATA}).
 \item[\const{NO\_RECOVERY}] si è avuto un errore non recuperabile
   nell'interrogazione di un server DNS.
 \item[\const{TRY\_AGAIN}] si è avuto un errore temporaneo nell'interrogazione
   di un server DNS, si può ritentare l'interrogazione in un secondo tempo. 
 \end{basedescript}
 
-
 Per capire meglio il contenuto della struttura \struct{hostent} conviene
 spendere alcune parole sul funzionamento del DNS. Questo in sostanza è un
 database distribuito organizzato in maniera gerarchica, interrogando il quale
-si possono avere una serie di informazioni la principale delle quali è la
+si possono avere una serie di informazioni, la principale delle quali è la
 corrispondenza fra un nome (a dominio) ed indirizzo IP.  Un server DNS
 contiene comunque una serie di altre informazioni; ciascuna voce nel database
 viene chiamata \textit{resource record} e vi è associato un certo
@@ -202,22 +267,31 @@ effettuare la risoluzione del nome, 
 vengono riempite le varie parti della struttura \struct{hostent}. Il primo
 campo della struttura, \var{h\_name} contiene sempre il \textsl{nome
   canonico}, che nel caso del DNS è appunto il nome associato ad un record
-\texttt{A}. Il secondo campo della struttura invece è un puntatore ad vettore
-di puntatori, terminato da un puntatore nullo. Ciascun puntatore del vettore
-fa riferimento ad una delle stringhe che contengono tutti i possibili altri
-nomi associati allo stesso indirzzo (quelli che nel DNS sarebbero record
-\texttt{CNAME}).
-
-Il terzo campo, \var{h\_addrtype}, indica il tipo di indirizzo che è stato
-restituito, e può essere solo \const{AF\_INET} o \const{AF\_INET6}, mentre il
-quarto campo, \var{h\_length}, indica la lunghezza dell'indirizzo stesso in
-byte. Infine il campo \var{h\_addr\_list} è il puntatore ad un vettore di
-puntatori ai singoli indirizzi; il vettore è terminato da un puntatore nullo.
-Inoltre, come illustrato in fig.~\ref{fig:sock_hostent_struct}, viene definito
-per compatibilità il campo \var{h\_addr} corrispondente al puntatore al primo
+\texttt{A}. Il secondo campo della struttura, \var{h\_aliases}, invece è un
+puntatore ad vettore di puntatori, terminato da un puntatore nullo. Ciascun
+puntatore del vettore punta ad una stringa contenente uno degli altri
+possibili nomi associati allo stesso \textsl{nome canonico} (quelli che nel
+DNS vengono inseriti come record di tipo \texttt{CNAME}).
+
+Il terzo campo della struttura, \var{h\_addrtype}, indica il tipo di indirizzo
+che è stato restituito, e può assumere soltanto i valori \const{AF\_INET} o
+\const{AF\_INET6}, mentre il quarto campo, \var{h\_length}, indica la
+lunghezza dell'indirizzo stesso in byte. Infine il campo \var{h\_addr\_list} è
+il puntatore ad un vettore di puntatori ai singoli indirizzi; il vettore è
+terminato da un puntatore nullo.  Inoltre, come illustrato in
+fig.~\ref{fig:sock_hostent_struct}, viene definito il campo \var{h\_addr} come
+sinonimo di \code{h\_addr\_list[0]}, cioè un riferimento diretto al primo
 indirizzo della lista.
 
-In sostanza 
+
+
+Oltre ai normali nomi a dominio la funzione accetta come argomento
+\param{name} anche indirizzi numerici, in formato dotted decimal per IPv4 o
+con la notazione illustrata in sez.~\ref{sec:IP_ipv6_notation}. In tal caso
+\func{gethostbyname} non eseguirà nessuna interrogazione remota, ma si
+limiterà a copiare la stringa nel campo \var{h\_name} ed a creare la
+corrispondente struttura \var{in\_addr} da indirizzara con
+\code{h\_addr\_list[0]}.
 
 
 
diff --git a/sources/myhost.c b/sources/myhost.c
new file mode 100644 (file)
index 0000000..eeb2e69
--- /dev/null
@@ -0,0 +1,125 @@
+/* myhost.c
+ * 
+ * Copyright (C) 2004 Simone Piccardi
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/*****************************************************************************
+ *
+ * File myhost.c: An example host command
+ *
+ * Author: S. Piccardi Jul. 2004
+ *
+ * $Id: myhost.c,v 1.1 2004/07/03 22:53:13 piccardi Exp $
+ *
+ *****************************************************************************/
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>        /* C standard library */
+#include <stdio.h>         /* I/O standard library */
+#include <unistd.h>
+#include <arpa/inet.h>
+extern int h_errno;
+
+#include "Gapil.h"
+/*
+ * Program myhost
+ *
+ * Use gethostbyname and print results
+ */
+/* Help printing routine */
+void usage(void);
+
+int main(int argc, char *argv[]) 
+{
+/* 
+ * Variables definition
+ */
+    int i;
+    struct hostent *data;
+    char **alias;
+    char *addr;
+    char buffer[INET6_ADDRSTRLEN];
+    /*
+     * Input section: decode command line parameters 
+     * Use getopt function
+     */
+    opterr = 0;         /* don't want writing to stderr */
+    while ( (i = getopt(argc, argv, "h")) != -1) {
+       switch (i) {
+       /* 
+        * Handling options 
+        */ 
+       case 'h':                                            /* help option */
+           printf("Wrong -h option use\n");
+           usage();
+           return -1;
+           break;
+       case '?':                                    /* unrecognized options */
+           printf("Unrecognized options -%c\n",optopt);
+           usage();
+       default:                                       /* should not reached */
+           usage();
+       }
+    }
+    /* ***********************************************************
+     * 
+     *          Options processing completed
+     *
+     *               Main code beginning
+     * 
+     * ***********************************************************/
+    if ((argc - optind) != 1) {
+       printf("Wrong number of arguments %d\n", argc - optind);
+        usage();
+    }
+    data = gethostbyname(argv[1]);
+    if (data == NULL) {
+       herror("Errore di risoluzione");
+       exit(1);
+    }
+    printf("Canonical name %s\n", data->h_name);
+    alias = data->h_aliases;
+    while (*alias != NULL) {
+       printf("Alias %s\n", *alias);
+       alias++;
+    }
+    if (data->h_addrtype == AF_INET) {
+       printf("Address are IPv4\n");
+    } else if (data->h_addrtype == AF_INET6) {
+       printf("Address are IPv6\n");
+    } else {
+       printf("Tipo di indirizzo non valido\n");
+       exit(1);
+    }
+    alias = data->h_addr_list;
+    while (*alias != NULL) {
+       addr = inet_ntop(data->h_addrtype, *alias, buffer, sizeof(buffer));
+       printf("Indirizzo %s\n", addr);
+       alias++;
+    }    
+    exit(0);
+}
+/*
+ * routine to print usage info and exit
+ */
+void usage(void) {
+    printf("Program myhost: do an hostname resolution \n");
+    printf("Usage:\n");
+    printf("  myhost [-h] hostname \n");
+    printf("  -h          print this help\n");
+    exit(1);
+}
index 3e2c164..3834b51 100644 (file)
@@ -1,4 +1,4 @@
-% system.tex
+%% system.tex
 %%
 %% Copyright (C) 2000-2003 Simone Piccardi.  Permission is granted to
 %% copy, distribute and/or modify this document under the terms of the GNU Free
@@ -66,11 +66,11 @@ chiara; in generale quello che succede 
 fissi essi vengono definiti come macro di preprocessore nel file
 \file{limits.h}, se invece possono variare, il loro valore sarà ottenibile
 tramite la funzione \func{sysconf} (che esamineremo in
-\secref{sec:sys_sysconf}).
+sez.~\ref{sec:sys_sysconf}).
 
 Lo standard ANSI C definisce dei limiti che sono tutti fissi, pertanto questo
 saranno sempre disponibili al momento della compilazione. Un elenco, ripreso
-da \file{limits.h}, è riportato in \tabref{tab:sys_ansic_macro}. Come si può
+da \file{limits.h}, è riportato in tab.~\ref{tab:sys_ansic_macro}. Come si può
 vedere per la maggior parte questi limiti attengono alle dimensioni dei dati
 interi, che sono in genere fissati dall'architettura hardware (le analoghe
 informazioni per i dati in virgola mobile sono definite a parte, ed
@@ -119,7 +119,7 @@ avere un valore minimo di 8.
 
 A questi valori lo standard ISO C90 ne aggiunge altri tre, relativi al tipo
 \ctyp{long long} introdotto con il nuovo standard, i relativi valori sono in
-\tabref{tab:sys_isoc90_macro}.
+tab.~\ref{tab:sys_isoc90_macro}.
 
 \begin{table}[htb]
   \centering
@@ -145,14 +145,14 @@ delle caratteristiche del sistema; mancano completamente tutte quelle che
 dipendono dalla implementazione dello stesso. Queste, per i sistemi unix-like,
 sono state definite in gran parte dallo standard POSIX.1, che tratta anche i
 limiti relativi alle caratteristiche dei file che vedremo in
-\secref{sec:sys_file_limits}.
+sez.~\ref{sec:sys_file_limits}.
 
 Purtroppo la sezione dello standard che tratta questi argomenti è una delle
 meno chiare\footnote{tanto che Stevens, in \cite{APUE}, la porta come esempio
   di ``standardese''.}. Lo standard prevede che ci siano 13 macro che
 descrivono le caratteristiche del sistema (7 per le caratteristiche generiche,
-riportate in \tabref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
-file, riportate in \tabref{tab:sys_file_macro}).
+riportate in tab.~\ref{tab:sys_generic_macro}, e 6 per le caratteristiche dei
+file, riportate in tab.~\ref{tab:sys_file_macro}).
 
 \begin{table}[htb]
   \centering
@@ -173,9 +173,9 @@ file, riportate in \tabref{tab:sys_file_macro}).
                               processo in contemporanea.\\
     \const{TZNAME\_MAX}&   6& dimensione massima del nome di una
                               \texttt{timezone} (vedi
-                              \secref{sec:sys_time_base})).\\  
+                              sez.~\ref{sec:sys_time_base})).\\  
     \const{NGROUPS\_MAX}& 32& numero di gruppi supplementari per
-                              processo (vedi \secref{sec:proc_access_id}).\\
+                              processo (vedi sez.~\ref{sec:proc_access_id}).\\
     \const{SSIZE\_MAX}&32767& valore massimo del tipo \type{ssize\_t}.\\
     \hline
     \hline
@@ -196,7 +196,7 @@ A complicare la faccenda si aggiunge il fatto che POSIX.1 prevede una serie di
 altre costanti (il cui nome inizia sempre con \code{\_POSIX\_}) che
 definiscono i valori minimi le stesse caratteristiche devono avere, perché una
 implementazione possa dichiararsi conforme allo standard; detti valori sono
-riportati in \tabref{tab:sys_posix1_general}.
+riportati in tab.~\ref{tab:sys_posix1_general}.
 
 \begin{table}[htb]
   \centering
@@ -219,10 +219,10 @@ riportati in \tabref{tab:sys_posix1_general}.
                                          processo in contemporanea.\\
     \const{\_POSIX\_TZNAME\_MAX} &     & dimensione massima del nome di una
                                          \texttt{timezone} (vedi
-                                         \secref{sec:sys_date}). \\ 
+                                         sez.~\ref{sec:sys_date}). \\ 
     \const{\_POSIX\_NGROUPS\_MAX}&    0& numero di gruppi supplementari per
                                          processo (vedi 
-                                         \secref{sec:proc_access_id}).\\
+                                         sez.~\ref{sec:proc_access_id}).\\
     \const{\_POSIX\_SSIZE\_MAX}  &32767& valore massimo del tipo 
                                          \type{ssize\_t}.\\
     \const{\_POSIX\_AIO\_LISTIO\_MAX}&2& \\
@@ -251,10 +251,10 @@ valori ottenuti da \func{sysconf}.
     \hline
     \macro{\_POSIX\_JOB\_CONTROL}& il sistema supporta il 
                                    \textit{job control} (vedi 
-                                   \secref{sec:sess_job_control}).\\
+                                   sez.~\ref{sec:sess_job_control}).\\
     \macro{\_POSIX\_SAVED\_IDS}  & il sistema supporta gli identificatori del 
                                    gruppo \textit{saved} (vedi 
-                                   \secref{sec:proc_access_id})
+                                   sez.~\ref{sec:proc_access_id})
                                    per il controllo di accesso dei processi\\
     \const{\_POSIX\_VERSION}     & fornisce la versione dello standard POSIX.1
                                    supportata nel formato YYYYMML (ad esempio 
@@ -267,12 +267,12 @@ valori ottenuti da \func{sysconf}.
 \end{table}
 
 Oltre ai precedenti valori (e a quelli relativi ai file elencati in
-\tabref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
+tab.~\ref{tab:sys_posix1_file}), che devono essere obbligatoriamente definiti,
 lo standard POSIX.1 ne prevede parecchi altri.  La lista completa si trova
 dall'header file \file{bits/posix1\_lim.h} (da non usare mai direttamente, è
 incluso automaticamente all'interno di \file{limits.h}). Di questi vale la
 pena menzionare alcune macro di uso comune, (riportate in
-\tabref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
+tab.~\ref{tab:sys_posix1_other}), che non indicano un valore specifico, ma
 denotano la presenza di alcune funzionalità nel sistema (come il supporto del
 \textit{job control} o degli identificatori del gruppo \textit{saved}).
 
@@ -288,7 +288,7 @@ manuale di \func{sysconf} e nel manuale delle \acr{glibc}.
 \subsection{La funzione \func{sysconf}}
 \label{sec:sys_sysconf}
 
-Come accennato in \secref{sec:sys_limits} quando uno dei limiti o delle
+Come accennato in sez.~\ref{sec:sys_limits} quando uno dei limiti o delle
 caratteristiche del sistema può variare, per non dover essere costretti a
 ricompilare un programma tutte le volte che si cambiano le opzioni con cui è
 compilato il kernel, o alcuni dei parametri modificabili a run time, è
@@ -304,7 +304,7 @@ prototipo di questa funzione 
 
 La funzione prende come argomento un intero che specifica quale dei limiti si
 vuole conoscere; uno specchietto contenente i principali valori disponibili in
-Linux è riportato in \tabref{tab:sys_sysconf_par}; l'elenco completo è
+Linux è riportato in tab.~\ref{tab:sys_sysconf_par}; l'elenco completo è
 contenuto in \file{bits/confname.h}, ed una lista più esaustiva, con le
 relative spiegazioni, si può trovare nel manuale delle \acr{glibc}.
 
@@ -331,21 +331,21 @@ relative spiegazioni, si pu
       specifica la macro {FOPEN\_MAX}.\\
       \texttt{\_SC\_TZNAME\_MAX}&\const{TZNAME\_MAX}&
       La dimensione massima di un nome di una \texttt{timezone} (vedi
-      \secref{sec:sys_date}).\\ 
+      sez.~\ref{sec:sys_date}).\\ 
       \texttt{\_SC\_NGROUPS\_MAX}&\const{NGROUP\_MAX}&
       Massimo numero di gruppi supplementari che può avere un processo (vedi
-      \secref{sec:proc_access_id}).\\ 
+      sez.~\ref{sec:proc_access_id}).\\ 
       \texttt{\_SC\_SSIZE\_MAX}&\const{SSIZE\_MAX}& 
       valore massimo del tipo di dato \type{ssize\_t}.\\
       \texttt{\_SC\_CLK\_TCK}& \const{CLK\_TCK} &
       Il numero di \textit{clock tick} al secondo, cioè l'unità di misura del
-      \textit{process time} (vedi \secref{sec:sys_unix_time}).\\
+      \textit{process time} (vedi sez.~\ref{sec:sys_unix_time}).\\
       \texttt{\_SC\_JOB\_CONTROL}&\macro{\_POSIX\_JOB\_CONTROL}&
       Indica se è supportato il \textit{job control} (vedi
-      \secref{sec:sess_job_control}) in stile POSIX.\\
+      sez.~\ref{sec:sess_job_control}) in stile POSIX.\\
       \texttt{\_SC\_SAVED\_IDS}&\macro{\_POSIX\_SAVED\_IDS}&
       Indica se il sistema supporta i \textit{saved id} (vedi
-      \secref{sec:proc_access_id}).\\ 
+      sez.~\ref{sec:proc_access_id}).\\ 
       \texttt{\_SC\_VERSION}& \const{\_POSIX\_VERSION} &
       Indica il mese e l'anno di approvazione della revisione dello standard
       POSIX.1 a cui il sistema fa riferimento, nel formato YYYYMML, la
@@ -378,7 +378,7 @@ Come per le caratteristiche generali del sistema anche per i file esistono una
 serie di limiti (come la lunghezza del nome del file o il numero massimo di
 link) che dipendono sia dall'implementazione che dal filesystem in uso; anche
 in questo caso lo standard prevede alcune macro che ne specificano il valore,
-riportate in \tabref{tab:sys_file_macro}.
+riportate in tab.~\ref{tab:sys_file_macro}.
 
 \begin{table}[htb]
   \centering
@@ -392,11 +392,12 @@ riportate in \tabref{tab:sys_file_macro}.
     \const{NAME\_MAX}&  14  & lunghezza in byte di un nome di file. \\
     \const{PATH\_MAX}& 256  & lunghezza in byte di un pathname.\\
     \const{PIPE\_BUF}&4096  & byte scrivibili atomicamente in una pipe
-                              (vedi \secref{sec:ipc_pipes}).\\
+                              (vedi sez.~\ref{sec:ipc_pipes}).\\
     \const{MAX\_CANON}&255  & dimensione di una riga di terminale in modo 
-                              canonico (vedi \secref{sec:term_design}).\\
+                              canonico (vedi sez.~\ref{sec:term_design}).\\
     \const{MAX\_INPUT}&255  & spazio disponibile nella coda di input 
-                              del terminale (vedi \secref{sec:term_design}).\\
+                              del terminale (vedi 
+                              sez.~\ref{sec:term_design}).\\
     \hline                
   \end{tabular}
   \caption{Costanti per i limiti sulle caratteristiche dei file.}
@@ -406,8 +407,8 @@ riportate in \tabref{tab:sys_file_macro}.
 Come per i limiti di sistema, lo standard POSIX.1 detta una serie di valori
 minimi anche per queste caratteristiche, che ogni sistema che vuole essere
 conforme deve rispettare; le relative macro sono riportate in
-\tabref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per le
-analoghe di \tabref{tab:sys_posix1_general}.
+tab.~\ref{tab:sys_posix1_file}, e per esse vale lo stesso discorso fatto per
+le analoghe di tab.~\ref{tab:sys_posix1_general}.
 
 \begin{table}[htb]
   \centering
@@ -489,7 +490,7 @@ il suo prototipo 
 La funzione, che viene usata dal comando \cmd{uname}, restituisce le
 informazioni richieste nella struttura \param{info}; anche questa struttura è
 definita in \file{sys/utsname.h}, secondo quanto mostrato in
-\secref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
+sez.~\ref{fig:sys_utsname}, e le informazioni memorizzate nei suoi membri
 indicano rispettivamente:
 \begin{itemize*}
 \item il nome del sistema operativo;
@@ -500,8 +501,8 @@ indicano rispettivamente:
 \item il nome del domino.
 \end{itemize*}
 l'ultima informazione è stata aggiunta di recente e non è prevista dallo
-standard POSIX, essa è accessibile, come mostrato in \figref{fig:sys_utsname},
-solo definendo \macro{\_GNU\_SOURCE}.
+standard POSIX, essa è accessibile, come mostrato in
+fig.~\ref{fig:sys_utsname}, solo definendo \macro{\_GNU\_SOURCE}.
 
 \begin{figure}[!htb]
   \footnotesize \centering
@@ -646,7 +647,7 @@ inclusa nei sorgenti del kernel, nella directory \file{Documentation/sysctl}.
 
 Ma oltre alle informazioni ottenibili da \func{sysctl} dentro \file{proc} 
 sono disponibili moltissime altre informazioni, fra cui ad esempio anche
-quelle fornite da \func{uname} (vedi \secref{sec:sys_config}) che sono
+quelle fornite da \func{uname} (vedi sez.~\ref{sec:sys_config}) che sono
 mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
 \file{version} e \file{domainname} di \file{/proc/kernel/}.
 
@@ -655,7 +656,7 @@ mantenute nei file \file{ostype}, \file{hostname}, \file{osrelease},
 \subsection{La gestione delle proprietà dei filesystem}
 \label{sec:sys_file_config}
 
-Come accennato in \secref{sec:file_organization} per poter accedere ai file
+Come accennato in sez.~\ref{sec:file_organization} per poter accedere ai file
 occorre prima rendere disponibile al sistema il filesystem su cui essi sono
 memorizzati; l'operazione di attivazione del filesystem è chiamata
 \textsl{montaggio}, per far questo in Linux\footnote{la funzione è specifica
@@ -703,7 +704,7 @@ contenuto su un disco, e l'operazione di montaggio corrisponde a rendere
 visibile al sistema il contenuto del suddetto disco, identificato attraverso
 il file di dispositivo ad esso associato.
 
-Ma la struttura del virtual filesystem vista in \secref{sec:file_vfs} è molto
+Ma la struttura del virtual filesystem vista in sez.~\ref{sec:file_vfs} è molto
 più flessibile e può essere usata anche per oggetti diversi da un disco. Ad
 esempio usando il \textit{loop device} si può montare un file qualunque (come
 l'immagine di un CD-ROM o di un floppy) che contiene un filesystem, inoltre
@@ -739,7 +740,7 @@ significativi sono un \textit{magic number}\footnote{cio
   riservata al \textit{magic number}.} mentre i 16 meno significativi sono
 usati per specificare le opzioni; essi sono usati come maschera binaria e
 vanno impostati con un OR aritmetico della costante \const{MS\_MGC\_VAL} con i
-valori riportati in \tabref{tab:sys_mount_flags}.
+valori riportati in tab.~\ref{tab:sys_mount_flags}.
 
 \begin{table}[htb]
   \footnotesize
@@ -756,13 +757,13 @@ valori riportati in \tabref{tab:sys_mount_flags}.
     \const{MS\_SYNCHRONOUS}& 16 & abilita la scrittura sincrona \\
     \const{MS\_REMOUNT}    & 32 & rimonta il filesystem cambiando i flag\\
     \const{MS\_MANDLOCK}   & 64 & consente il \textit{mandatory locking} (vedi
-                                  \secref{sec:file_mand_locking})\\
+                                  sez.~\ref{sec:file_mand_locking})\\
     \const{S\_WRITE}      & 128 & scrive normalmente \\
     \const{S\_APPEND}     & 256 & consente la scrittura solo in \textit{append
-                                  mode} (vedi \secref{sec:file_sharing})\\
+                                  mode} (vedi sez.~\ref{sec:file_sharing})\\
     \const{S\_IMMUTABLE}  & 512 & impedisce che si possano modificare i file \\
     \const{MS\_NOATIME}   &1024 & non aggiorna gli \textit{access time} (vedi
-                                  \secref{sec:file_file_times})\\
+                                  sez.~\ref{sec:file_file_times})\\
     \const{MS\_NODIRATIME}&2048 & non aggiorna gli \textit{access time} delle
                                   directory\\
     \const{MS\_BIND}      &4096 & monta il filesystem altrove\\
@@ -861,7 +862,7 @@ informazioni riguardo al filesystem su cui si trova un certo file, sono
 Queste funzioni permettono di ottenere una serie di informazioni generali
 riguardo al filesystem su cui si trova il file specificato; queste vengono
 restituite all'indirizzo \param{buf} di una struttura \struct{statfs} definita
-come in \figref{fig:sys_statfs}, ed i campi che sono indefiniti per il
+come in fig.~\ref{fig:sys_statfs}, ed i campi che sono indefiniti per il
 filesystem in esame sono impostati a zero.  I valori del campo \var{f\_type}
 sono definiti per i vari filesystem nei relativi file di header dei sorgenti
 del kernel da costanti del tipo \var{XXX\_SUPER\_MAGIC}, dove \var{XXX} in
@@ -894,30 +895,61 @@ tralasceremo la trattazione, rimandando al manuale delle \acr{glibc}
 \cite{glibc} per la documentazione completa.
 
 
-\subsection{La gestione di utenti e gruppi}
+\subsection{La gestione delle informazioni su utenti e gruppi}
 \label{sec:sys_user_group}
 
-Tradizionalmente l'informazione per la gestione di utenti e gruppi veniva
-tenuta tutta nei due file di testo \file{/etc/passwd} ed \file{/etc/group}, e
-tutte le funzioni facevano riferimento ad essi.  Oggi la maggior parte delle
-distribuzioni di Linux usa la libreria PAM (sigla che sta \textit{Pluggable
-  Authentication Method}) che permette di separare completamente i meccanismi
-di gestione degli utenti (autenticazione, riconoscimento, ecc.) dalle modalità
-in cui i relativi dati vengono mantenuti, per cui pur restando in gran parte
-le stesse\footnote{in genere quello che viene cambiato è l'informazione usata
-  per l'autenticazione, che non è più necessariamente una password criptata da
-  verificare, ma può assumere le forme più diverse, come impronte digitali,
-  chiavi elettroniche, ecc.}, le informazioni non sono più necessariamente
-mantenute in quei file.
-
-In questo paragrafo ci limiteremo comunque alle funzioni classiche per la
-lettura delle informazioni relative a utenti e gruppi previste dallo standard
-POSIX.1, che fanno riferimento a quanto memorizzato nei due file appena
-citati, il cui formato è descritto dalle relative pagine del manuale (cioè
-\cmd{man 5 passwd} e \cmd{man 5 group}).
-
-Per leggere le informazioni relative ad un utente si possono usare due
-funzioni, \funcd{getpwuid} e \funcd{getpwnam}, i cui prototipi sono:
+Tradizionalmente le informazioni utilizzate nella gestione di utenti e gruppi
+(password, corripondenze fra nomi simbolici e user-id, home directory, ecc.)
+venivano registrate all'interno dei due file di testo \file{/etc/passwd} ed
+\file{/etc/group},\footnote{in realtà oltre a questi nelle distribuzioni più
+  recenti è stato introdotto il sistema delle \textit{shadow password} che
+  prevede anche i due file \file{/etc/shadow} e \file{/etc/gshadow}, in cui
+  sono state spostate le informazioni di autenticazione (ed inserite alcune
+  estensioni) per toglierle dagli altri file che devono poter essere letti per
+  poter effettuare l'associazione fra username e \acr{uid}.} il cui formato è
+descritto dalle relative pagine del manuale\footnote{nella quinta sezione,
+  quella dei file di configurazione, occorre cioè usare \cmd{man 5 passwd}
+  dato che altrimenti si avrebbe la pagina di manuale del comando
+  \cmd{passwd}.} e tutte le funzioni che richiedevano l'accesso a queste
+informazione andavano a leggere direttamente il contenuto di questi file.
+
+Col tempo però questa impostazione ha incominciato a mostrare dei limiti: da
+una parte il meccanismo classico di autenticazione è stato ampliato, ed oggi
+la maggior parte delle distribuzioni di GNU/Linux usa la libreria PAM (sigla
+che sta per \textit{Pluggable Authentication Method}) che fornisce una
+interfaccia comune per i processi di autenticazione,\footnote{il
+  \textit{Pluggable Authentication Method} è un sistema modulare, in cui è
+  possibile utilizzare anche più meccanismi insieme, diventa così possibile
+  avere vari sistemi di riconoscimento (biometria, chiavi hardware, ecc.),
+  diversi formati per le password e diversi supporti per le informazioni, il
+  tutto in maniera trasparente per le applicazioni purché per ciascun
+  meccanismo si disponga della opportuna libreria che implementa l'interfaccia
+  di PAM.}  svincolando completamente le singole applicazione dai dettagli del
+come questa viene eseguita e di dove vengono mantenuti i dati relativi;
+dall'altra con il diffondersi delle reti la necessità di centralizzare le
+informazioni degli utenti e dei gruppi per insiemi di macchine, in modo da
+mantenere coerenti i dati, ha portato anche alla necessità di poter recuperare
+e memorizzare dette informazioni su supporti diversi, introducendo il sistema
+del \textit{Name Service Switch} che tratteremo in dettaglio più avanti (in
+sez.~\ref{sec:sock_resolver}) dato che la maggior parte delle sua applicazioni
+sono relative alla risoluzioni di nomi di rete.
+
+In questo paragrafo ci limiteremo comunque a trattere le funzioni classiche
+per la lettura delle informazioni relative a utenti e gruppi tralasciando
+completamente quelle relative all'autenticazione. 
+%  Per questo non tratteremo
+% affatto l'interfaccia di PAM, ma approfondiremo invece il sistema del
+% \textit{Name Service Switch}, un meccanismo messo a disposizione dalle
+% \acr{glibc} per modularizzare l'accesso a tutti i servizi in cui sia
+% necessario trovare una corrispondenza fra un nome ed un numero (od altra
+% informazione) ad esso associato, come appunto, quella fra uno username ed un
+% \acr{uid} o fra un \acr{gid} ed il nome del gruppo corrispondente.
+Le prime funzioni che vedremo sono quelle previste dallo standard POSIX.1;
+queste sono del tutto generiche e si appoggiano direttamente al \textit{Name
+  Service Switch}, per cui sono in grado di ricevere informazioni qualunque
+sia il supporto su cui esse vengono mantenute.  Per leggere le informazioni
+relative ad un utente si possono usare due funzioni, \funcd{getpwuid} e
+\funcd{getpwnam}, i cui prototipi sono:
 \begin{functions}
   \headdecl{pwd.h} 
   \headdecl{sys/types.h} 
@@ -932,13 +964,13 @@ funzioni, \funcd{getpwuid} e \funcd{getpwnam}, i cui prototipi sono:
     trovato nessun utente corrispondente a quanto specificato.}
 \end{functions}
 
-Le due funzioni forniscono le informazioni memorizzate nel database degli
+Le due funzioni forniscono le informazioni memorizzate nel registro degli
 utenti (che nelle versioni più recenti possono essere ottenute attraverso PAM)
 relative all'utente specificato attraverso il suo \acr{uid} o il nome di
 login. Entrambe le funzioni restituiscono un puntatore ad una struttura di
 tipo \struct{passwd} la cui definizione (anch'essa eseguita in \file{pwd.h}) è
-riportata in \figref{fig:sys_passwd_struct}, dove è pure brevemente illustrato
-il significato dei vari campi. 
+riportata in fig.~\ref{fig:sys_passwd_struct}, dove è pure brevemente
+illustrato il significato dei vari campi.
 
 \begin{figure}[!htb]
   \footnotesize
@@ -956,8 +988,9 @@ La struttura usata da entrambe le funzioni 
 motivo viene sovrascritta ad ogni nuova invocazione, lo stesso dicasi per la
 memoria dove sono scritte le stringhe a cui i puntatori in essa contenuti
 fanno riferimento. Ovviamente questo implica che dette funzioni non possono
-essere rientranti, per cui ne esistono anche due versioni alternative
-(denotate dalla solita estensione \code{\_r}), i cui prototipi sono:
+essere rientranti; per questo motivo ne esistono anche due versioni
+alternative (denotate dalla solita estensione \code{\_r}), i cui prototipi
+sono:
 \begin{functions}
   \headdecl{pwd.h} 
   
@@ -1015,7 +1048,7 @@ Il comportamento di tutte queste funzioni 
 precedenti che leggono le informazioni sugli utenti, l'unica differenza è che
 in questo caso le informazioni vengono restituite in una struttura di tipo
 \struct{group}, la cui definizione è riportata in
-\figref{fig:sys_group_struct}.
+fig.~\ref{fig:sys_group_struct}.
 
 \begin{figure}[!htb]
   \footnotesize
@@ -1029,13 +1062,17 @@ in questo caso le informazioni vengono restituite in una struttura di tipo
   \label{fig:sys_group_struct}
 \end{figure}
 
-Le funzioni viste finora sono in grado di leggere le informazioni sia dal file
-delle password in \file{/etc/passwd} che con qualunque altro metodo sia stato
-utilizzato per mantenere il database degli utenti. Non permettono però di
-impostare direttamente le password; questo è possibile con un'altra interfaccia
-al database degli utenti, derivata da SVID, che però funziona soltanto con un
-database che sia tenuto su un file che abbia il formato classico di
-\file{/etc/passwd}.
+Le funzioni viste finora sono in grado di leggere le informazioni sia
+direttamente dal file delle password in \file{/etc/passwd} che tramite il
+sistema del \textit{Name Service Switch} e sono completamente generiche. Si
+noti però che non c'è una funzione che permetta di impostare direttamente una
+password.\footnote{in realtà questo può essere fatto ricorrendo a PAM, ma
+  questo è un altro discorso.} Dato che POSIX non prevede questa possibilità
+esiste un'altra interfaccia che lo fa, derivata da SVID le cui funzioni sono
+riportate in tab.~\ref{tab:sys_passwd_func}. Questa però funziona soltanto
+quando le informazioni sono mantenute su un apposito file di \textsl{registro}
+di utenti e gruppi, con il formato classico di \file{/etc/passwd} e
+\file{/etc/group}.
 
 \begin{table}[htb]
   \footnotesize
@@ -1045,56 +1082,58 @@ database che sia tenuto su un file che abbia il formato classico di
     \textbf{Funzione} & \textbf{Significato}\\
     \hline
     \hline
-    \func{fgetpwent}   & Legge una voce dal database utenti da un file 
-                         specificato aprendolo la prima volta.\\
+    \func{fgetpwent}   & Legge una voce dal file di registro degli utenti
+                         specificato.\\
     \func{fgetpwent\_r}& Come la precedente, ma rientrante.\\
-    \func{getpwent}    & Legge una voce dal database utenti (da 
-                         \file{/etc/passwd}) aprendolo la prima volta.\\
+    \func{putpwent}    & Immette una voce in un file di registro degli
+                         utenti.\\ 
+    \func{getpwent}    & Legge una voce da \file{/etc/passwd}.\\
     \func{getpwent\_r} & Come la precedente, ma rientrante.\\
-    \func{setpwent}    & Ritorna all'inizio del database.\\
-    \func{putpwent}    & Immette una voce nel database utenti.\\
-    \func{endpwent}    & Chiude il database degli utenti.\\
-    \func{fgetgrent}   & Legge una voce dal database dei gruppi da un file 
-                         specificato aprendolo la prima volta.\\
+    \func{setpwent}    & Ritorna all'inizio di \file{/etc/passwd}.\\
+    \func{endpwent}    & Chiude \file{/etc/passwd}.\\
+    \func{fgetgrent}   & Legge una voce dal file di registro dei gruppi 
+                         specificato.\\
     \func{fgetgrent\_r}& Come la precedente, ma rientrante.\\
-    \func{getgrent}    & Legge una voce dal database dei gruppi (da 
-                         \file{/etc/passwd}) aprendolo la prima volta.\\
+    \func{putgrent}    & Immette una voce in un file di registro dei gruppi.\\
+    \func{getgrent}    & Legge una voce da \file{/etc/group}.\\ 
     \func{getgrent\_r} & Come la precedente, ma rientrante.\\
-    \func{setgrent}    & Immette una voce nel database dei gruppi.\\
-    \func{putgrent}    & Immette una voce nel database dei gruppi.\\
-    \func{endgrent}    & Chiude il database dei gruppi.\\
+    \func{setgrent}    & Ritorna all'inizio di \file{/etc/group}.\\
+    \func{endgrent}    & Chiude \file{/etc/group}.\\
     \hline
   \end{tabular}
   \caption{Funzioni per la manipolazione dei campi di un file usato come
-    database di utenti e gruppi nel formato di \file{/etc/passwd} e
+    registro per utenti o gruppi nel formato di \file{/etc/passwd} e
     \file{/etc/groups}.} 
   \label{tab:sys_passwd_func}
 \end{table}
 
-Dato che ormai la gran parte delle distribuzioni di Linux utilizzano PAM, che
-come minimo usa almeno le \textit{shadow password} (quindi con delle modifiche
-rispetto al formato classico di \file{/etc/passwd}), le funzioni che danno la
-capacità scrivere delle voci nel database (cioè \func{putpwent} e
-\func{putgrent}) non permettono di effettuarne una specificazione in maniera
-completa. Per questo motivo l'uso di queste funzioni è deprecato in favore
-dell'uso di PAM, ci limiteremo pertanto ad elencarle in
-\tabref{tab:sys_passwd_func}, rimandando chi fosse interessato alle rispettive
-pagine di manuale e al manuale delle \acr{glibc} per i dettagli del loro
-funzionamento.
+Dato che oramai la gran parte delle distribuzioni di GNU/Linux utilizzano
+almeno le \textit{shadow password} (quindi con delle modifiche rispetto al
+formato classico del file \file{/etc/passwd}), si tenga presente che le
+funzioni di questa interfaccia che permettono di scrivere delle voci in un
+\textsl{registro} degli utenti (cioè \func{putpwent} e \func{putgrent}) non
+hanno la capacità di farlo specificando tutti i contenuti necessari rispetto a
+questa estensione. Per questo motivo l'uso di queste funzioni è deprecato, in
+quanto comunque non funzionale, pertanto ci limiteremo a fornire soltanto
+l'elenco di tab.~\ref{tab:sys_passwd_func}, senza nessuna spiegazione
+ulteriore.  Chi volesse insistere ad usare questa interfaccia può fare
+riferimento alle pagine di manuale delle rispettive funzioni ed al manuale
+delle \acr{glibc} per i dettagli del funzionamento.
 
 
 
-\subsection{Il database di accounting}
+\subsection{Il registro della \textsl{contabilità} degli utenti}
 \label{sec:sys_accounting}
 
 L'ultimo insieme di funzioni relative alla gestione del sistema che
-esamineremo è quello che permette di accedere ai dati del database di
-\textit{accounting}.  In esso vengono mantenute una serie di informazioni
-storiche relative sia agli utenti che si sono collegati al sistema, (tanto per
-quelli correntemente collegati, che per la registrazione degli accessi
-precedenti), sia relative all'intero sistema, come il momento di lancio di
-processi da parte di \cmd{init}, il cambiamento dell'orologio di sistema, il
-cambiamento di runlevel o il riavvio della macchina.
+esamineremo è quello che permette di accedere ai dati del registro della
+cosiddetta \textsl{contabilità} (o \textit{accounting}) degli utenti.  In esso
+vengono mantenute una serie di informazioni storiche relative sia agli utenti
+che si sono collegati al sistema, (tanto per quelli correntemente collegati,
+che per la registrazione degli accessi precedenti), sia relative all'intero
+sistema, come il momento di lancio di processi da parte di \cmd{init}, il
+cambiamento dell'orologio di sistema, il cambiamento di runlevel o il riavvio
+della macchina.
 
 I dati vengono usualmente\footnote{questa è la locazione specificata dal
   \textit{Linux Filesystem Hierarchy Standard}, adottato dalla gran parte
@@ -1115,25 +1154,24 @@ informazioni sono descritte in dettaglio nel manuale delle \acr{glibc}.
 Questi file non devono mai essere letti direttamente, ma le informazioni che
 contengono possono essere ricavate attraverso le opportune funzioni di
 libreria. Queste sono analoghe alle precedenti funzioni (vedi
-\tabref{tab:sys_passwd_func}) usate per accedere al database degli utenti,
-solo che in questo caso la struttura del database di accounting è molto più
-complessa, dato che contiene diversi tipi di informazione.
+tab.~\ref{tab:sys_passwd_func}) usate per accedere al registro degli utenti,
+solo che in questo caso la struttura del registro della \textsl{contabilità} è
+molto più complessa, dato che contiene diversi tipi di informazione.
 
 Le prime tre funzioni, \funcd{setutent}, \funcd{endutent} e \funcd{utmpname}
 servono rispettivamente a aprire e a chiudere il file che contiene il
-database, e a specificare su quale file esso viene mantenuto. I loro prototipi
+registro, e a specificare su quale file esso viene mantenuto. I loro prototipi
 sono:
 \begin{functions}
   \headdecl{utmp.h} 
   
   \funcdecl{void utmpname(const char *file)} Specifica il file da usare come
-  database di \textit{accounting}.
+  registro.
   
-  \funcdecl{void setutent(void)} Apre il file del database di
-  \textit{accounting}, posizionandosi al suo inizio.
+  \funcdecl{void setutent(void)} Apre il file del registro, posizionandosi al
+  suo inizio.
   
-  \funcdecl{void endutent(void)} Chiude il file del database di
-  \textit{accounting}.
+  \funcdecl{void endutent(void)} Chiude il file del registro.
   
   \bodydesc{Le funzioni non ritornano codici di errore.}
 \end{functions}
@@ -1142,10 +1180,10 @@ In caso questo non venga specificato nessun file viene usato il valore
 standard \const{\_PATH\_UTMP} (che è definito in \file{paths.h}); in genere
 \func{utmpname} prevede due possibili valori:
 \begin{basedescript}{\desclabelwidth{2.0cm}}
-\item[\const{\_PATH\_UTMP}] Specifica il database di accounting per gli utenti
-  correntemente collegati.
-\item[\const{\_PATH\_WTMP}] Specifica il database di accounting per l'archivio
-  storico degli utenti collegati.
+\item[\const{\_PATH\_UTMP}] Specifica il registro per gli utenti correntemente
+  collegati.
+\item[\const{\_PATH\_WTMP}] Specifica il registro per l'archivio storico degli
+  utenti collegati.
 \end{basedescript}
 corrispondenti ai file \file{/var/run/utmp} e \file{/var/log/wtmp} visti in
 precedenza.
@@ -1158,7 +1196,7 @@ precedenza.
   \end{minipage} 
   \normalsize 
   \caption{La struttura \structd{utmp} contenente le informazioni di una voce
-    del database di \textit{accounting}.}
+    del registro di \textsl{contabilità}.}
   \label{fig:sys_utmp_struct}
 \end{figure}
 
@@ -1169,31 +1207,31 @@ e \funcd{pututline}, i cui prototipi sono:
   \headdecl{utmp.h} 
 
   \funcdecl{struct utmp *getutent(void)} 
-  Legge una voce dal dalla posizione corrente nel database.
+  Legge una voce dal dalla posizione corrente nel registro.
   
-  \funcdecl{struct utmp *getutid(struct utmp *ut)} 
-  Ricerca una voce sul database in base al contenuto di \param{ut}.
+  \funcdecl{struct utmp *getutid(struct utmp *ut)} Ricerca una voce sul
+  registro in base al contenuto di \param{ut}.
 
   \funcdecl{struct utmp *getutline(struct utmp *ut)} 
-  Ricerca nel database la prima voce corrispondente ad un processo sulla linea
+  Ricerca nel registro la prima voce corrispondente ad un processo sulla linea
   di terminale specificata tramite \param{ut}.
 
   \funcdecl{struct utmp *pututline(struct utmp *ut)} 
-  Scrive una voce nel database.
+  Scrive una voce nel registro.
   
   \bodydesc{Le funzioni ritornano il puntatore ad una struttura \struct{utmp}
     in caso di successo e \val{NULL} in caso di errore.}
 \end{functions}
 
-Tutte queste funzioni fanno riferimento ad una struttura di tipo \struct{utmp},
-la cui definizione in Linux è riportata in \figref{fig:sys_utmp_struct}. Le
-prime tre funzioni servono per leggere una voce dal database; \func{getutent}
-legge semplicemente la prima voce disponibile; le altre due permettono di
-eseguire una ricerca.
+Tutte queste funzioni fanno riferimento ad una struttura di tipo
+\struct{utmp}, la cui definizione in Linux è riportata in
+fig.~\ref{fig:sys_utmp_struct}. Le prime tre funzioni servono per leggere una
+voce dal registro; \func{getutent} legge semplicemente la prima voce
+disponibile; le altre due permettono di eseguire una ricerca.
 
 Con \func{getutid} si può cercare una voce specifica, a seconda del valore del
 campo \var{ut\_type} dell'argomento \param{ut}.  Questo può assumere i valori
-riportati in \tabref{tab:sys_ut_type}, quando assume i valori
+riportati in tab.~\ref{tab:sys_ut_type}, quando assume i valori
 \const{RUN\_LVL}, \const{BOOT\_TIME}, \const{OLD\_TIME}, \const{NEW\_TIME},
 verrà restituito la prima voce che corrisponde al tipo determinato; quando
 invece assume i valori \const{INIT\_PROCESS}, \const{LOGIN\_PROCESS},
@@ -1222,7 +1260,7 @@ corrispondente al valore del campo \var{ut\_id} specificato in \param{ut}.
 %    \const{ACCOUNTING}    & ??? \\
     \hline
   \end{tabular}
-  \caption{Classificazione delle voci del database di accounting a seconda dei
+  \caption{Classificazione delle voci del registro a seconda dei
     possibili valori del campo \var{ut\_type}.} 
   \label{tab:sys_ut_type}
 \end{table}
@@ -1233,7 +1271,7 @@ restituendo la prima che corrisponde al valore di \var{ut\_line}, che
 specifica il device\footnote{espresso senza il \file{/dev/} iniziale.} di
 terminale che interessa. Lo stesso criterio di ricerca è usato da
 \func{pututline} per trovare uno spazio dove inserire la voce specificata,
-qualora non sia trovata la voce viene aggiunta in coda al database.
+qualora non sia trovata la voce viene aggiunta in coda al registro.
 
 In generale occorre però tenere conto che queste funzioni non sono
 completamente standardizzate, e che in sistemi diversi possono esserci
@@ -1249,7 +1287,7 @@ gestione (\func{getutxent}, \func{getutxid}, \func{getutxline},
 \func{pututxline}, \func{setutxent} e \func{endutxent}) sono ridefinite come
 sinonimi delle funzioni appena viste.
 
-Come visto in \secref{sec:sys_user_group}, l'uso di strutture allocate
+Come visto in sez.~\ref{sec:sys_user_group}, l'uso di strutture allocate
 staticamente rende le funzioni di lettura non rientranti; per questo motivo le
 \acr{glibc} forniscono anche delle versioni rientranti: \func{getutent\_r},
 \func{getutid\_r}, \func{getutline\_r}, che invece di restituire un puntatore
@@ -1266,11 +1304,10 @@ prototipi sono:
   \headdecl{utmp.h} 
   
   \funcdecl{void updwtmp(const char *wtmp\_file, const struct utmp *ut)}
-  Aggiunge la voce \param{ut} nel database di accounting \file{wmtp}.
+  Aggiunge la voce \param{ut} nel registro \file{wmtp}.
   
   \funcdecl{void logwtmp(const char *line, const char *name, const char
-    *host)} Aggiunge nel database di accounting una voce con i valori
-  specificati.
+    *host)} Aggiunge nel registro una voce con i valori specificati.
 \end{functions}
 
 La prima funzione permette l'aggiunta di una voce a \file{wmtp} specificando
@@ -1286,17 +1323,18 @@ poi aggiunge chiamando \func{updwtmp}.
 Dopo aver esaminato le funzioni che permettono di controllare le varie
 caratteristiche, capacità e limiti del sistema a livello globale, in questa
 sezione tratteremo le varie funzioni che vengono usate per quantificare le
-risorse (CPU, memoria, ecc.)  utilizzate da ogni singolo processo e quelle che
-permettono di imporre a ciascuno di essi vincoli e limiti di utilizzo.
+risorse (CPU, memoria, ecc.) utilizzate da ogni singolo processo e quelle che
+permettono di imporre a ciascuno di essi vincoli e limiti di
+utilizzo. 
 
 
 \subsection{L'uso delle risorse}
 \label{sec:sys_resource_use}
 
-Come abbiamo accennato in \secref{sec:proc_wait4} le informazioni riguardo
+Come abbiamo accennato in sez.~\ref{sec:proc_wait4} le informazioni riguardo
 l'utilizzo delle risorse da parte di un processo è mantenuto in una struttura
 di tipo \struct{rusage}, la cui definizione (che si trova in
-\file{sys/resource.h}) è riportata in \figref{fig:sys_rusage_struct}.
+\file{sys/resource.h}) è riportata in fig.~\ref{fig:sys_rusage_struct}.
 
 \begin{figure}[!htb]
   \footnotesize
@@ -1310,29 +1348,33 @@ di tipo \struct{rusage}, la cui definizione (che si trova in
   \label{fig:sys_rusage_struct}
 \end{figure}
 
-La definizione della struttura in \figref{fig:sys_rusage_struct} è ripresa da
-BSD 4.3, ma attualmente (con i kernel della serie 2.4.x) i soli campi che sono
-mantenuti sono: \var{ru\_utime}, \var{ru\_stime}, \var{ru\_minflt},
-\var{ru\_majflt}, e \var{ru\_nswap}. I primi due indicano rispettivamente il
-tempo impiegato dal processo nell'eseguire le istruzioni in user space, e
-quello impiegato dal kernel nelle system call eseguite per conto del processo.
+La definizione della struttura in fig.~\ref{fig:sys_rusage_struct} è ripresa
+da BSD 4.3,\footnote{questo non ha a nulla a che fare con il \textit{BSD
+    accounting} che si trova nelle opzioni di compilazione del kernel (e di
+  norma è disabilitato) che serve per mantenere una contabilità delle risorse
+  usate da ciascun processo in maniera molto più dettagliata.} ma attualmente
+(con i kernel della serie 2.4.x e 2.6.x) i soli campi che sono mantenuti sono:
+\var{ru\_utime}, \var{ru\_stime}, \var{ru\_minflt}, \var{ru\_majflt}, e
+\var{ru\_nswap}. I primi due indicano rispettivamente il tempo impiegato dal
+processo nell'eseguire le istruzioni in user space, e quello impiegato dal
+kernel nelle system call eseguite per conto del processo.
 
 Gli altri tre campi servono a quantificare l'uso della memoria
 virtuale\index{memoria virtuale} e corrispondono rispettivamente al numero di
-\textit{page fault}\index{page fault} (vedi \secref{sec:proc_mem_gen})
-avvenuti senza richiedere I/O (i cosiddetti \textit{minor page fault}), a
-quelli che invece han richiesto I/O (detti invece \textit{major page fault})
-ed al numero di volte che il processo è stato completamente tolto dalla
-memoria per essere inserito nello swap.
+\textit{page fault}\index{page fault} (vedi sez.~\ref{sec:proc_mem_gen})
+avvenuti senza richiedere I/O su disco (i cosiddetti \textit{minor page
+  fault}), a quelli che invece han richiesto I/O su disco (detti invece
+\textit{major page fault}) ed al numero di volte che il processo è stato
+completamente tolto dalla memoria per essere inserito nello swap.
 
 In genere includere esplicitamente \file{<sys/time.h>} non è più strettamente
 necessario, ma aumenta la portabilità, e serve comunque quando, come nella
 maggior parte dei casi, si debba accedere ai campi di \struct{rusage} relativi
-ai tempi di utilizzo del processore, che sono definiti come strutture
+ai tempi di utilizzo del processore, che sono definiti come strutture di tipo
 \struct{timeval}.
 
 Questa è la stessa struttura utilizzata da \func{wait4} (si ricordi quando
-visto in \secref{sec:proc_wait4}) per ricavare la quantità di risorse
+visto in sez.~\ref{sec:proc_wait4}) per ricavare la quantità di risorse
 impiegate dal processo di cui si è letto lo stato di terminazione, ma essa può
 anche essere letta direttamente utilizzando la funzione \funcd{getrusage}, il
 cui prototipo è:
@@ -1359,21 +1401,36 @@ ricevuto lo stato di terminazione.
 \subsection{Limiti sulle risorse}
 \label{sec:sys_resource_limit}
 
-Come accennato nell'introduzione oltre a leggere l'uso delle risorse da parte
-di un processo si possono anche imporre dei limiti sulle sue capacità. Ogni
-processo ha in generale due limiti associati ad ogni risorsa; questi sono
-detti il \textsl{limite corrente} (o \textit{current limit}) che esprime il
-valore che attualmente il processo non può superare, ed il \textsl{limite
-  massimo} (o \textit{maximum limit}) che esprime il valore massimo che può
-assumere il \textsl{limite corrente}.
-
-In generale il primo viene chiamato un limite \textsl{soffice} (o \textit{soft
-  limit}) dato che il suo valore può essere aumentato, mentre il secondo è
-detto \textsl{duro} (o \textit{hard limit}), in quanto un processo normale non
-può modificarne il valore. Il valore di questi limiti è mantenuto in una
-struttura \struct{rlimit}, la cui definizione è riportata in
-\figref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a limite
-corrente e limite massimo.
+Come accennato nell'introduzione oltre a mantenere i dati relativi all'uso
+delle risorse da parte dei vari processi, il kernel mette anche a disposizione
+delle funzioni con cui si possono imporre dei limiti sulle risorse che essi
+possono utilizzare.  In generale ad ogni processo vengono associati due
+diversi limiti per ogni risorsa; questi sono detti il \textsl{limite corrente}
+(o \textit{current limit}) che esprime il valore massimo che attualmente il
+processo non può superare, ed il \textsl{limite massimo} (o \textit{maximum
+  limit}) che esprime il valore massimo che può assumere il \textsl{limite
+  corrente}.
+
+\begin{figure}[!htb]
+  \footnotesize
+  \centering
+  \begin{minipage}[c]{15cm}
+    \includestruct{listati/rlimit.h}
+  \end{minipage} 
+  \normalsize 
+  \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
+    delle risorse usate da un processo.}
+  \label{fig:sys_rlimit_struct}
+\end{figure}
+
+In generale il primo viene chiamato anche \textsl{limite soffice} (o
+\textit{soft limit}) dato che il suo valore può essere aumentato fino al
+valore del secondo, mentre il secondo è detto \textsl{limite duro} (o
+\textit{hard limit}), in quanto un processo normale può solo diminuirne il
+valore. Il valore di questi due limiti è mantenuto in una struttura
+\struct{rlimit}, la cui definizione è riportata in
+fig.~\ref{fig:sys_rlimit_struct}, ed i cui campi corrispondono appunto a
+limite corrente e limite massimo.
 
 In genere il superamento di un limite comporta o l'emissione di un segnale o
 il fallimento della system call che lo ha provocato; per permettere di leggere
@@ -1403,23 +1460,10 @@ prototipi sono:
   ed \errval{EFAULT}.}
 \end{functions}
 
-\begin{figure}[!htb]
-  \footnotesize
-  \centering
-  \begin{minipage}[c]{15cm}
-    \includestruct{listati/rlimit.h}
-  \end{minipage} 
-  \normalsize 
-  \caption{La struttura \structd{rlimit} per impostare i limiti di utilizzo 
-    delle risorse usate da un processo.}
-  \label{fig:sys_rlimit_struct}
-\end{figure}
-
-
 
 Entrambe le funzioni permettono di specificare, attraverso l'argomento
 \param{resource}, su quale risorsa si vuole operare: i possibili valori di
-questo argomento sono elencati in \secref{tab:sys_rlimit_values}. L'acceso
+questo argomento sono elencati in sez.~\ref{tab:sys_rlimit_values}. L'acceso
 (rispettivamente in lettura e scrittura) ai valori effettivi dei limiti viene
 poi effettuato attraverso la struttura \struct{rlimit} puntata da
 \param{rlim}.
@@ -1465,7 +1509,7 @@ poi effettuato attraverso la struttura \struct{rlimit} puntata da
     \const{RLIMIT\_MEMLOCK}&  L'ammontare massimo di memoria che può essere
                               bloccata in RAM senza
                               paginazione\index{paginazione} (vedi
-                              \secref{sec:proc_mem_lock}).\\ 
+                              sez.~\ref{sec:proc_mem_lock}).\\ 
     \const{RLIMIT\_AS}     &  La dimensione massima di tutta la memoria che il
                               processo può ottenere. Se il processo tenta di
                               allocarne di più  funzioni come \func{brk},
@@ -1479,28 +1523,28 @@ poi effettuato attraverso la struttura \struct{rlimit} puntata da
 
 \footnotetext{Impostare questo limite a zero è la maniera più semplice per
   evitare la creazione di \file{core} file (al proposito si veda
-  \secref{sec:sig_prog_error}).}
+  sez.~\ref{sec:sig_prog_error}).}
 
 Nello specificare un limite, oltre a fornire dei valori specifici, si può
 anche usare la costante \const{RLIM\_INFINITY} che permette di sbloccare l'uso
 di una risorsa; ma si ricordi che solo un processo con i privilegi di
 amministratore può innalzare un limite al di sopra del valore corrente del
 limite massimo. Si tenga conto infine che tutti i limiti vengono ereditati dal
-processo padre attraverso una \func{fork} (vedi \secref{sec:proc_fork}) e
+processo padre attraverso una \func{fork} (vedi sez.~\ref{sec:proc_fork}) e
 mantenuti per gli altri programmi eseguiti attraverso una \func{exec} (vedi
-\secref{sec:proc_exec}).
+sez.~\ref{sec:proc_exec}).
 
 
 \subsection{Le risorse di memoria e processore}
 \label{sec:sys_memory_res}
 
 La gestione della memoria è già stata affrontata in dettaglio in
-\secref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
+sez.~\ref{sec:proc_memory}; abbiamo visto allora che il kernel provvede il
 meccanismo della memoria virtuale\index{memoria virtuale} attraverso la
 divisione della memoria fisica in pagine.
 
 In genere tutto ciò è del tutto trasparente al singolo processo, ma in certi
-casi, come per l'I/O mappato in memoria (vedi \secref{sec:file_memory_map})
+casi, come per l'I/O mappato in memoria (vedi sez.~\ref{sec:file_memory_map})
 che usa lo stesso meccanismo per accedere ai file, è necessario conoscere le
 dimensioni delle pagine usate dal kernel. Lo stesso vale quando si vuole
 gestire in maniera ottimale l'interazione della memoria che si sta allocando
@@ -1600,8 +1644,8 @@ Storicamente i sistemi unix-like hanno sempre mantenuto due distinti tipi di
 dati per la misure dei tempi all'interno del sistema: essi sono
 rispettivamente chiamati \textit{calendar time} e \textit{process time},
 secondo le definizioni:
-\begin{description}
-\item[\textit{calendar time}]: detto anche \textsl{tempo di calendario}. È il
+\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{calendar time}] detto anche \textsl{tempo di calendario}. È il
   numero di secondi dalla mezzanotte del primo gennaio 1970, in tempo
   universale coordinato (o UTC), data che viene usualmente indicata con
   00:00:00 Jan, 1 1970 (UTC) e chiamata \textit{the Epoch}. Questo tempo viene
@@ -1610,20 +1654,20 @@ secondo le definizioni:
   del kernel, 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 \type{time\_t}.
-\item[\textit{process time}]: detto talvolta \textsl{tempo di processore}.
+\item[\textit{process time}] detto talvolta \textsl{tempo di processore}.
   Viene misurato in \textit{clock tick}. Un tempo questo corrispondeva al
   numero di interruzioni effettuate dal timer di sistema, adesso lo standard
   POSIX richiede che esso sia pari al valore della costante
   \const{CLOCKS\_PER\_SEC}, che deve essere definita come 1000000, qualunque
   sia la risoluzione reale dell'orologio di sistema e la frequenza delle
   interruzioni del timer.\footnote{quest'ultima, come accennato in
-    \secref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.} Il
-  dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi una
-  risoluzione del microsecondo. Il numero di tick al secondo può essere
-  ricavato anche attraverso \func{sysconf} (vedi \secref{sec:sys_sysconf}). Il
-  vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
+    sez.~\ref{sec:proc_hierarchy}, è invece data dalla costante \const{HZ}.}
+  Il dato primitivo usato per questo tempo è \type{clock\_t}, che ha quindi
+  una risoluzione del microsecondo. Il numero di tick al secondo può essere
+  ricavato anche attraverso \func{sysconf} (vedi sez.~\ref{sec:sys_sysconf}).
+  Il vecchio simbolo \const{CLK\_TCK} definito in \file{time.h} è ormai
   considerato obsoleto.
-\end{description}
+\end{basedescript}
 
 In genere si usa il \textit{calendar time} per esprimere le date dei file e le
 informazioni analoghe che riguardano i cosiddetti \textsl{tempi di orologio},
@@ -1641,21 +1685,29 @@ una precisione ovviamente superiore al \textit{calendar time} (che 
 dal sistema con una granularità di un secondo) e viene usato per tenere conto
 dei tempi di esecuzione dei processi. Per ciascun processo il kernel calcola
 tre tempi diversi:
-\begin{description}
-\item[\textit{clock time}]: il tempo \textsl{reale} (viene chiamato anche
+\begin{basedescript}{\desclabelwidth{1.5cm}\desclabelstyle{\nextlinelabel}}
+\item[\textit{clock time}] il tempo \textsl{reale} (viene chiamato anche
   \textit{wall clock time} o \textit{elapsed time}) passato dall'avvio del
   processo. Chiaramente tale tempo dipende anche dal carico del sistema e da
   quanti altri processi stavano girando nello stesso periodo.
-\item[\textit{user time}]: il tempo che la CPU ha impiegato nell'esecuzione
-  delle istruzioni del processo in user space.
-\item[\textit{system time}]: il tempo che la CPU ha impiegato nel kernel per
-  eseguire delle system call per conto del processo.
-\end{description}
+  
+\item[\textit{user time}] il tempo effettivo che il processore ha impiegato
+  nell'esecuzione delle istruzioni del processo in user space. È quello
+  riportato nella risorsa \var{ru\_utime} di \struct{rusage} vista in
+  sez.~\ref{sec:sys_resource_use}.
+  
+\item[\textit{system time}] il tempo effettivo che il processore ha impiegato
+  per eseguire codice delle system call nel kernel per conto del processo.  È
+  quello riportato nella risorsa \var{ru\_stime} di \struct{rusage} vista in
+  sez.~\ref{sec:sys_resource_use}.
+\end{basedescript}
 
 In genere la somma di \textit{user time} e \textit{system time} indica il
-tempo di processore totale in cui il sistema è stato effettivamente impegnato
-nell'eseguire un certo processo e viene chiamato \textit{CPU time} o
-\textsl{tempo di CPU}.
+tempo di processore totale che il sistema ha effettivamente utilizzato per
+eseguire un certo processo, questo viene chiamato anche \textit{CPU time} o
+\textsl{tempo di CPU}. Si può ottenere un riassunto dei valori di questi tempi
+quando si esegue un qualsiasi programma lanciando quest'ultimo come argomento
+del comando \cmd{time}.
 
 
 
@@ -1689,7 +1741,7 @@ secondi occorre moltiplicare il risultato per la costante
 valore massimo corrispondente a circa 72 minuti, dopo i quali il contatore
 riprenderà lo stesso valore iniziale.
 
-Come accennato in \secref{sec:sys_unix_time} il tempo di CPU è la somma di
+Come accennato in sez.~\ref{sec:sys_unix_time} il tempo di CPU è la somma di
 altri due tempi, l'\textit{user time} ed il \textit{system time} che sono
 quelli effettivamente mantenuti dal kernel per ciascun processo. Questi
 possono essere letti attraverso la funzione \funcd{times}, il cui prototipo è:
@@ -1702,10 +1754,10 @@ possono essere letti attraverso la funzione \funcd{times}, il cui prototipo 
 
 La funzione restituisce i valori di process time del processo corrente in una
 struttura di tipo \struct{tms}, la cui definizione è riportata in
-\secref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
+sez.~\ref{fig:sys_tms_struct}. La struttura prevede quattro campi; i primi due,
 \var{tms\_utime} e \var{tms\_stime}, sono l'\textit{user time} ed il
 \textit{system time} del processo, così come definiti in
-\secref{sec:sys_unix_time}.
+sez.~\ref{sec:sys_unix_time}.
 
 \begin{figure}[!htb]
   \footnotesize
@@ -1735,7 +1787,7 @@ verranno considerati nel calcolo di questi tempi.
 \subsection{Le funzioni per il \textit{calendar time}}
 \label{sec:sys_time_base}
 
-Come anticipato in \secref{sec:sys_unix_time} il \textit{calendar time} è
+Come anticipato in sez.~\ref{sec:sys_unix_time} il \textit{calendar time} è
 mantenuto dal kernel in una variabile di tipo \type{time\_t}, che usualmente
 corrisponde ad un tipo elementare (in Linux è definito come \ctyp{long int},
 che di norma corrisponde a 32 bit).  Il valore corrente del \textit{calendar
@@ -1794,7 +1846,7 @@ sono:
 
 Queste funzioni utilizzano una struttura di tipo \struct{timeval}, la cui
 definizione, insieme a quella della analoga \struct{timespec}, è riportata in
-\figref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
+fig.~\ref{fig:sys_timeval_struct}. Le \acr{glibc} infatti forniscono queste due
 rappresentazioni alternative del \textit{calendar time} che rispetto a
 \type{time\_t} consentono rispettivamente precisioni del microsecondo e del
 nanosecondo.\footnote{la precisione è solo teorica, la precisione reale della
@@ -1881,12 +1933,12 @@ prototipo 
 
 La funzione richiede una struttura di tipo \struct{timex}, la cui definizione,
 così come effettuata in \file{sys/timex.h}, è riportata in
-\figref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
+fig.~\ref{fig:sys_timex_struct}. L'azione della funzione dipende dal valore del
 campo \var{mode}, che specifica quale parametro dell'orologio di sistema,
 specificato in un opportuno campo di \struct{timex}, deve essere impostato. Un
 valore nullo serve per leggere i parametri correnti; i valori diversi da zero
 devono essere specificati come OR binario delle costanti riportate in
-\secref{tab:sys_timex_mode}.
+sez.~\ref{tab:sys_timex_mode}.
 
 La funzione utilizza il meccanismo di David L. Mills, descritto
 nell'\href{http://www.ietf.org/rfc/rfc1305.txt}{RFC~1305}, che è alla base del
@@ -1894,14 +1946,14 @@ protocollo NTP. La funzione 
 portabilità è un requisito, le \acr{glibc} provvedono anche un suo omonimo
 \func{ntp\_adjtime}.  La trattazione completa di questa funzione necessita di
 una lettura approfondita del meccanismo descritto nell'RFC~1305, ci limitiamo
-a descrivere in \tabref{tab:sys_timex_mode} i principali valori utilizzabili
+a descrivere in tab.~\ref{tab:sys_timex_mode} i principali valori utilizzabili
 per il campo \var{mode}, un elenco più dettagliato del significato dei vari
 campi della struttura \struct{timex} può essere ritrovato in \cite{glibc}.
 
 \begin{table}[htb]
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|c| p{9cm}|}
+  \begin{tabular}[c]{|l|c|p{7cm}|}
     \hline
     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
     \hline
@@ -1956,7 +2008,7 @@ sintassi specificata per la forma equivalente di questa funzione definita come
 \begin{table}[htb]
   \footnotesize
   \centering
-  \begin{tabular}[c]{|l|c| p{10cm}|}
+  \begin{tabular}[c]{|l|c|l|}
     \hline
     \textbf{Nome} & \textbf{Valore} & \textbf{Significato}\\
     \hline
@@ -1975,7 +2027,7 @@ sintassi specificata per la forma equivalente di questa funzione definita come
 
 La funzione ritorna un valore positivo che esprime lo stato dell'orologio di
 sistema; questo può assumere i valori riportati in
-\tabref{tab:sys_adjtimex_return}.  Un valore di -1 viene usato per riportare
+tab.~\ref{tab:sys_adjtimex_return}.  Un valore di -1 viene usato per riportare
 un errore; al solito se si cercherà di modificare l'orologio di sistema
 (specificando un \var{mode} diverso da zero) senza avere i privilegi di
 amministratore si otterrà un errore di \errcode{EPERM}.
@@ -1993,13 +2045,13 @@ stata introdotta una ulteriore rappresentazione, detta \textit{broken-down
   time} usuale in ore, minuti, secondi, ecc.
 
 Questo viene effettuato attraverso una opportuna struttura \struct{tm}, la cui
-definizione è riportata in \figref{fig:sys_tm_struct}, ed è in genere questa
+definizione è riportata in fig.~\ref{fig:sys_tm_struct}, ed è in genere questa
 struttura che si utilizza quando si deve specificare un tempo a partire dai
 dati naturali (ora e data), dato che essa consente anche di trattare la
 gestione del fuso orario e dell'ora legale.\footnote{in realtà i due campi
   \var{tm\_gmtoff} e \var{tm\_zone} sono estensioni previste da BSD e dalle
   \acr{glibc}, che, quando è definita \macro{\_BSD\_SOURCE}, hanno la forma in
-  \figref{fig:sys_tm_struct}.}
+  fig.~\ref{fig:sys_tm_struct}.}
 
 Le funzioni per la gestione del \textit{broken-down time} sono varie e vanno
 da quelle usate per convertire gli altri formati in questo, usando o meno
@@ -2071,12 +2123,12 @@ due versioni rientranti (con la solita estensione \code{\_r}), che prevedono
 un secondo parametro \code{struct tm *result}, fornito dal chiamante, che deve
 preallocare la struttura su cui sarà restituita la conversione.
 
-Come mostrato in \figref{fig:sys_tm_struct} il \textit{broken-down time}
+Come mostrato in fig.~\ref{fig:sys_tm_struct} il \textit{broken-down time}
 permette di tenere conto anche della differenza fra tempo universale e ora
 locale, compresa l'eventuale ora legale. Questo viene fatto attraverso le tre
-variabili globali mostrate in \figref{fig:sys_tzname}, cui si accede quando si
-include \file{time.h}. Queste variabili vengono impostate quando si chiama una
-delle precedenti funzioni di conversione, oppure invocando direttamente la
+variabili globali mostrate in fig.~\ref{fig:sys_tzname}, cui si accede quando
+si include \file{time.h}. Queste variabili vengono impostate quando si chiama
+una delle precedenti funzioni di conversione, oppure invocando direttamente la
 funzione \funcd{tzset}, il cui prototipo è:
 \begin{prototype}{sys/timex.h}
 {void tzset(void)} 
@@ -2086,7 +2138,7 @@ funzione \funcd{tzset}, il cui prototipo 
   \bodydesc{La funzione non ritorna niente e non dà errori.}
 \end{prototype}
 
-La funzione inizializza le variabili di \figref{fig:sys_tzname} a partire dal
+La funzione inizializza le variabili di fig.~\ref{fig:sys_tzname} a partire dal
 valore della variabile di ambiente \const{TZ}, se quest'ultima non è definita
 verrà usato il file \file{/etc/localtime}.
 
@@ -2179,26 +2231,33 @@ viene utilizzato come modificatore; alcuni\footnote{per la precisione quelli
   le \acr{glibc} provvedono tutte le estensioni introdotte da POSIX.2 per il
   comando \cmd{date}, i valori introdotti da SVID3 e ulteriori estensioni GNU;
   l'elenco completo dei possibili valori è riportato nella pagina di manuale
-  della funzione.} dei possibili valori che esso può assumere sono riportati in
-\tabref{tab:sys_strftime_format}. La funzione tiene conto anche della presenza
-di una localizzazione per stampare in maniera adeguata i vari nomi.
+  della funzione.} dei possibili valori che esso può assumere sono riportati
+in tab.~\ref{tab:sys_strftime_format}. La funzione tiene conto anche della
+presenza di una localizzazione per stampare in maniera adeguata i vari nomi.
+
 
 
 \section{La gestione degli errori}
 \label{sec:sys_errors}
 
-La gestione degli errori è in genere una materia complessa. Inoltre il modello
-utilizzato dai sistema unix-like è basato sull'architettura a processi, e
-presenta una serie di problemi nel caso lo si debba usare con i thread.
-Esamineremo in questa sezione le sue caratteristiche principali.
+In questa sezione esamineremo le caratteristiche principali della gestione
+degli errori in un sistema unix-like. Infatti a parte il caso particolare di
+alcuni segnali (che tratteremo in cap.~\ref{cha:signals}) in un sistema
+unix-like il kernel non avvisa mai direttamente un processo dell'occorrenza di
+un errore nell'esecuzione di una funzione, ma di norma questo viene riportato
+semplicemente usando un opportuno valore di ritorno della funzione invocata.
+Inoltre il sistema di classificazione degli errori è basato sull'architettura
+a processi, e presenta una serie di problemi nel caso lo si debba usare con i
+thread.
 
 
 \subsection{La variabile \var{errno}}
 \label{sec:sys_errno}
 
-Quasi tutte le funzioni delle librerie del C sono in  grado di individuare e
-riportare condizioni di errore, ed è una buona norma di programmazione
-controllare sempre che le funzioni chiamate si siano concluse correttamente.
+Quasi tutte le funzioni delle librerie del C sono in grado di individuare e
+riportare condizioni di errore, ed è una norma fondamentale di buona
+programmazione controllare \textbf{sempre} che le funzioni chiamate si siano
+concluse correttamente.
 
 In genere le funzioni di libreria usano un valore speciale per indicare che
 c'è stato un errore. Di solito questo valore è -1 o un puntatore nullo o la
@@ -2212,13 +2271,13 @@ Per riportare il tipo di errore il sistema usa la variabile globale
   può anche usare una macro, e questo è infatti il modo usato da Linux per
   renderla locale ai singoli thread.} definita nell'header \file{errno.h}; la
 variabile è in genere definita come \direct{volatile} dato che può essere
-cambiata in modo asincrono da un segnale (si veda \secref{sec:sig_sigchld} per
-un esempio, ricordando quanto trattato in \secref{sec:proc_race_cond}), ma
-dato che un gestore di segnale scritto bene salva e ripristina il valore
+cambiata in modo asincrono da un segnale (si veda sez.~\ref{sec:sig_sigchld}
+per un esempio, ricordando quanto trattato in sez.~\ref{sec:proc_race_cond}),
+ma dato che un gestore di segnale scritto bene salva e ripristina il valore
 della variabile, di questo non è necessario preoccuparsi nella programmazione
 normale.
 
-I valori che può assumere \var{errno} sono riportati in \capref{cha:errors},
+I valori che può assumere \var{errno} sono riportati in app.~\ref{cha:errors},
 nell'header \file{errno.h} sono anche definiti i nomi simbolici per le
 costanti numeriche che identificano i vari errori; essi iniziano tutti per
 \val{E} e si possono considerare come nomi riservati. In seguito faremo
@@ -2303,7 +2362,7 @@ evitare i problemi connessi alla condivisione del buffer statico. Il messaggio
 altrimenti la stringa viene troncata.
 
 Una seconda funzione usata per riportare i codici di errore in maniera
-automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
+automatizzata sullo standard error (vedi sez.~\ref{sec:file_std_descr}) è
 \funcd{perror}, il cui prototipo è:
 \begin{prototype}{stdio.h}{void perror(const char *message)} 
   Stampa il messaggio di errore relativo al valore corrente di \var{errno}
@@ -2311,7 +2370,7 @@ automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) 
 \end{prototype}
 
 I messaggi di errore stampati sono gli stessi di \func{strerror}, (riportati
-in \capref{cha:errors}), e, usando il valore corrente di \var{errno}, si
+in app.~\ref{cha:errors}), e, usando il valore corrente di \var{errno}, si
 riferiscono all'ultimo errore avvenuto. La stringa specificata con
 \param{message} viene stampato prima del messaggio d'errore, seguita dai due
 punti e da uno spazio, il messaggio è terminato con un a capo.
@@ -2333,7 +2392,7 @@ equivalente a quello di \func{strerror}.
   \label{fig:sys_err_mess}
 \end{figure}
 
-In \figref{fig:sys_err_mess} è riportata la sezione attinente del codice del
+In fig.~\ref{fig:sys_err_mess} è riportata la sezione attinente del codice del
 programma \cmd{errcode}, che può essere usato per stampare i messaggi di
 errore e le costanti usate per identificare i singoli errori; il sorgente
 completo del programma è allegato nel file \file{ErrCode.c} e contiene pure la