Correzioni ortografiche.
authorSimone Piccardi <piccardi@gnulinux.it>
Tue, 31 Dec 2002 18:25:39 +0000 (18:25 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Tue, 31 Dec 2002 18:25:39 +0000 (18:25 +0000)
fileadv.tex
filedir.tex
fileunix.tex
intro.tex
ipc.tex
process.tex
prochand.tex
session.tex
signal.tex
socket.tex

index 8765038..78adf08 100644 (file)
@@ -2033,7 +2033,7 @@ opportune verifiche nei processi, questo verrebbe comunque rispettato.
 Per poter utilizzare il \textit{mandatory locking} è stato introdotto un
 utilizzo particolare del bit \acr{sgid}. Se si ricorda quanto esposto in
 \secref{sec:file_suid_sgid}), esso viene di norma utilizzato per cambiare il
-groupid effettivo con cui viene eseguito un programma, ed è pertanto sempre
+group-ID effettivo con cui viene eseguito un programma, ed è pertanto sempre
 associato alla presenza del permesso di esecuzione per il gruppo. Impostando
 questo bit su un file senza permesso di esecuzione in un sistema che supporta
 il \textit{mandatory locking}, fa sì che quest'ultimo venga attivato per il
index 5afbc54..fed54e0 100644 (file)
@@ -537,7 +537,7 @@ prototipo 
   \begin{errlist}
   \item[\errcode{EPERM}] Il filesystem non supporta la cancellazione di
     directory, oppure la directory che contiene \param{dirname} ha lo sticky
-    bit impostato e l'userid effettivo del processo non corrisponde al
+    bit impostato e l'user-ID effettivo del processo non corrisponde al
     proprietario della directory.
   \item[\errcode{EACCES}] Non c'è il permesso di scrittura per la directory
     che contiene la directory che si vuole cancellare, o non c'è il permesso
@@ -1848,8 +1848,8 @@ in una directory con lo \textsl{sticky bit} impostato (si veda
 La procedura con cui il kernel stabilisce se un processo possiede un certo
 permesso (di lettura, scrittura o esecuzione) si basa sul confronto fra
 l'utente e il gruppo a cui il file appartiene (i valori di \var{st\_uid} e
-\var{st\_gid} accennati in precedenza) e l'userid effettivo, il groupid
-effettivo e gli eventuali groupid supplementari del processo.\footnote{in
+\var{st\_gid} accennati in precedenza) e l'user-ID effettivo, il group-ID
+effettivo e gli eventuali group-ID supplementari del processo.\footnote{in
   realtà Linux, per quanto riguarda l'accesso ai file, utilizza gli gli
   identificatori del gruppo \textit{filesystem} (si ricordi quanto esposto in
   \secref{sec:proc_perms}), ma essendo questi del tutto equivalenti ai primi,
@@ -1858,19 +1858,19 @@ effettivo e gli eventuali groupid supplementari del processo.\footnote{in
 
 Per una spiegazione dettagliata degli identificatori associati ai processi si
 veda \secref{sec:proc_perms}; normalmente, a parte quanto vedremo in
-\secref{sec:file_suid_sgid}, l'userid effettivo e il groupid effettivo
+\secref{sec:file_suid_sgid}, l'user-ID effettivo e il group-ID effettivo
 corrispondono ai valori dell'\acr{uid} e del \acr{gid} dell'utente che ha
-lanciato il processo, mentre i groupid supplementari sono quelli dei gruppi
+lanciato il processo, mentre i group-ID supplementari sono quelli dei gruppi
 cui l'utente appartiene.
 
 I passi attraverso i quali viene stabilito se il processo possiede il diritto
 di accesso sono i seguenti:
 \begin{enumerate}
-\item Se l'userid effettivo del processo è zero (corrispondente
+\item Se l'user-ID effettivo 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
   tutti i file.
-\item Se l'userid effettivo del processo è uguale all'\acr{uid} del
+\item Se l'user-ID effettivo del processo è uguale all'\acr{uid} del
   proprietario del file (nel qual caso si dice che il processo è proprietario
   del file) allora:
   \begin{itemize*}
@@ -1880,7 +1880,7 @@ di accesso sono i seguenti:
     impostato, l'accesso è consentito
   \item altrimenti l'accesso è negato
   \end{itemize*}
-\item Se il groupid effettivo del processo o uno dei groupid supplementari dei
+\item Se il group-ID effettivo del processo o uno dei group-ID supplementari dei
   processi corrispondono al \acr{gid} del file allora:
   \begin{itemize*}
   \item se il bit dei permessi d'accesso del gruppo è impostato, l'accesso è
@@ -1919,9 +1919,9 @@ corrispondono dell'utente con cui si 
 Se però il file del programma (che ovviamente deve essere
 eseguibile\footnote{per motivi di sicurezza il kernel ignora i bit \acr{suid}
   e \acr{sgid} per gli script eseguibili.}) ha il bit \acr{suid} impostato, il
-kernel assegnerà come userid effettivo al nuovo processo l'\acr{uid} del
+kernel assegnerà come user-ID effettivo al nuovo processo l'\acr{uid} del
 proprietario del file al posto dell'\acr{uid} del processo originario.  Avere
-il bit \acr{sgid} impostato ha lo stesso effetto sul groupid effettivo del
+il bit \acr{sgid} impostato ha lo stesso effetto sul group-ID effettivo del
 processo.
 
 I bit \acr{suid} e \acr{sgid} vengono usati per permettere agli utenti normali
@@ -2021,10 +2021,10 @@ per la creazione di nuove directory (procedimento descritto in
 \secref{sec:file_dir_creat_rem}).
 
 Lo standard POSIX prescrive che l'\acr{uid} del nuovo file corrisponda
-all'userid effettivo del processo che lo crea; per il \acr{gid} invece prevede
+all'user-ID effettivo del processo che lo crea; per il \acr{gid} invece prevede
 due diverse possibilità:
 \begin{itemize*}
-\item il \acr{gid} del file corrisponde al groupid effettivo del processo.
+\item il \acr{gid} del file corrisponde al group-ID effettivo del processo.
 \item il \acr{gid} del file corrisponde al \acr{gid} della directory in cui
   esso è creato.
 \end{itemize*}
@@ -2050,9 +2050,9 @@ con il \acr{gid} del gruppo primario dello stesso.
 \label{sec:file_access}
 
 Come visto in \secref{sec:file_access_control} il controllo di accesso ad un
-file viene fatto utilizzando l'userid ed il groupid effettivo del processo; ci
-sono casi però in cui si può voler effettuare il controllo con l'userid reale
-ed il groupid reale, vale a dire usando i valori di \acr{uid} e \acr{gid}
+file viene fatto utilizzando l'user-ID ed il group-ID effettivo del processo; ci
+sono casi però in cui si può voler effettuare il controllo con l'user-ID reale
+ed il group-ID reale, vale a dire usando i valori di \acr{uid} e \acr{gid}
 relativi all'utente che ha lanciato il programma, e che, come accennato in
 \secref{sec:file_suid_sgid} e spiegato in dettaglio in
 \secref{sec:proc_perms}, non è detto siano uguali a quelli effettivi.  
@@ -2137,7 +2137,7 @@ filename e su un file descriptor, i loro prototipi sono:
   \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} può assumere i valori:
   \begin{errlist}
-  \item[\errcode{EPERM}] L'userid effettivo non corrisponde a quello del
+  \item[\errcode{EPERM}] L'user-ID effettivo non corrisponde a quello del
     proprietario del file o non è zero.
     \item[\errcode{EROFS}] Il file è su un filesystem in sola lettura.
   \end{errlist}
@@ -2200,7 +2200,7 @@ bit \acr{suid} il valore da fornire sarebbe $4755$.
 
 Il cambiamento dei permessi di un file eseguito attraverso queste funzioni ha
 comunque alcune limitazioni, previste per motivi di sicurezza. L'uso delle
-funzioni infatti è possibile solo se l'userid effettivo del processo
+funzioni infatti è possibile solo se l'user-ID effettivo del processo
 corrisponde a quello del proprietario del file o dell'amministratore,
 altrimenti esse falliranno con un errore di \errcode{EPERM}.
 
@@ -2210,7 +2210,7 @@ non tutti i valori possibili di \param{mode} sono permessi o hanno effetto;
 in particolare accade che:
 \begin{enumerate}
 \item siccome solo l'amministratore può impostare lo \textit{sticky bit}, se
-  l'userid effettivo del processo non è zero esso viene automaticamente
+  l'user-ID effettivo del processo non è zero esso viene automaticamente
   cancellato (senza notifica di errore) qualora sia stato indicato in
   \param{mode}.
 \item per quanto detto in \secref{sec:file_ownership} riguardo la creazione
@@ -2220,7 +2220,7 @@ in particolare accade che:
   per cui non si hanno diritti, questo viene automaticamente cancellato da
   \param{mode} (senza notifica di errore) qualora il gruppo del file non
   corrisponda a quelli associati al processo (la cosa non avviene quando
-  l'userid effettivo del processo è zero).
+  l'user-ID effettivo del processo è zero).
 \end{enumerate}
 
 Per alcuni filesystem\footnote{il filesystem \acr{ext2} supporta questa
@@ -2292,7 +2292,7 @@ sono:
   \bodydesc{Le funzioni restituiscono zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} può assumere i valori:
   \begin{errlist}
-  \item[\errcode{EPERM}] L'userid effettivo non corrisponde a quello del
+  \item[\errcode{EPERM}] L'user-ID effettivo non corrisponde a quello del
     proprietario del file o non è zero, o utente e gruppo non sono validi
   \end{errlist}
   Oltre a questi entrambe restituiscono gli errori \errval{EROFS} e
@@ -2454,7 +2454,7 @@ radice con la funzione \funcd{chroot}, il cui prototipo 
 \bodydesc{La funzione restituisce zero in caso di successo e -1 per
     un errore, in caso di errore \var{errno} può assumere i valori:
   \begin{errlist}
-  \item[\errcode{EPERM}] L'userid effettivo del processo non è zero.
+  \item[\errcode{EPERM}] L'user-ID effettivo del processo non è zero.
   \end{errlist}
   ed inoltre \errval{EFAULT}, \errval{ENAMETOOLONG}, \errval{ENOENT},
   \errval{ENOMEM}, \errval{ENOTDIR}, \errval{EACCES}, \errval{ELOOP};
index 0863017..b23698a 100644 (file)
@@ -129,7 +129,7 @@ quindi alla lettura della tastiera). Il secondo file 
 inviati i dati in uscita (sempre nel caso della shell, è associato all'uscita
 del terminale, e quindi alla scrittura sullo schermo). Il terzo è lo
 \textit{standard error}, su cui viene inviato l'output relativo agli errori,
-ed è anch'esso associato all'uscita del termininale.  Lo standard POSIX.1
+ed è anch'esso associato all'uscita del terminale.  Lo standard POSIX.1
 provvede tre costanti simboliche, definite nell'header \file{unistd.h}, al
 posto di questi valori numerici:
 \begin{table}[htb]
@@ -253,7 +253,7 @@ usato sempre il file descriptor con il valore pi
     valore specifica anche una modalità di operazione (vedi sotto), e 
     comporta che \func{open} ritorni immediatamente (l'opzione ha senso 
     solo per le fifo, torneremo questo in \secref{sec:ipc_named_pipe}). \\
-    \const{O\_NOCTTY} & se \param{pathname} si riferisce ad un device di
+    \const{O\_NOCTTY} & se \param{pathname} si riferisce ad un dispositivo di
     terminale, questo non diventerà il terminale di controllo, anche se il
     processo non ne ha ancora uno (si veda \secref{sec:sess_ctrl_term}). \\
     \const{O\_SHLOCK} & opzione di BSD, acquisisce uno shared lock (vedi
@@ -951,7 +951,7 @@ dell'output fra l'esecuzione di una \func{fork} e la successiva \func{exec};
 diventa così possibile associare un file (o una pipe) allo standard input o
 allo standard output (torneremo sull'argomento in \secref{sec:ipc_pipe_use},
 quando tratteremo le pipe). Per fare questo in genere occorre prima chiudere
-il file che si vuole sostituire, cossicché il suo file descriptor possa esser
+il file che si vuole sostituire, cosicché il suo file descriptor possa esser
 restituito alla chiamata di \func{dup}, come primo file descriptor
 disponibile.
 
@@ -983,7 +983,7 @@ funzione di controllo dei file \func{fnctl} (che esamineremo in
 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 fra le due funzioni\footnote{a parte la sistassi ed i
+La sola differenza fra le due funzioni\footnote{a parte la sintassi ed i
   diversi codici di errore.} è che \func{dup2} chiude il file descriptor
 \param{newfd} se questo è già aperto, garantendo che la duplicazione sia
 effettuata esattamente su di esso, invece \func{fcntl} restituisce il primo
@@ -999,7 +999,7 @@ tutta una serie di operazioni ausiliarie che 
 descriptor, che non riguardano la normale lettura e scrittura di dati, ma la
 gestione sia delle loro proprietà, che di tutta una serie di ulteriori
 funzionalità che il kernel può mettere a disposizione.\footnote{ad esempio si
-  gesticono con questa funzione l'I/O asincrono (vedi
+  gestiscono con questa funzione l'I/O asincrono (vedi
   \secref{sec:file_asyncronous_io}) e il file locking\index{file!locking}
   (vedi \secref{sec:file_locking}).}
 
@@ -1112,7 +1112,7 @@ le tematiche relative all'I/O asincrono sono trattate in maniera esaustiva in
 
 Si tenga presente infine che quando si usa la funzione per determinare le
 modalità di accesso con cui è stato aperto il file (attraverso l'uso del
-comando \const{F\_GETFL}) è necessario estrarre i bit corripondenti nel
+comando \const{F\_GETFL}) è necessario estrarre i bit corrispondenti nel
 \textit{file status flag} che si è ottenuto.  Infatti la definizione corrente
 di quest'ultimo non assegna bit separati alle tre diverse modalità
 \const{O\_RDONLY}, \const{O\_WRONLY} e \const{O\_RDWR}.\footnote{in Linux
index 27a1d33..74ec9f2 100644 (file)
--- a/intro.tex
+++ b/intro.tex
@@ -252,10 +252,10 @@ definendo gruppi di lavoro, di accesso a determinate risorse, etc.
 L'utente e il gruppo sono identificati da due numeri (la cui corrispondenza ad
 un nome espresso in caratteri è inserita nei due file \file{/etc/passwd} e
 \file{/etc/groups}). Questi numeri sono l'\textit{user identifier}, detto in
-breve \textsl{userid}, ed indicato dall'acronimo \acr{uid}, e il \textit{group
-  identifier}, detto in breve \textsl{groupid}, ed identificato dall'acronimo
-\acr{gid}, e sono quelli che vengono usati dal kernel per identificare
-l'utente.
+breve \textsl{user-ID}, ed indicato dall'acronimo \acr{uid}, e il
+\textit{group identifier}, detto in breve \textsl{group-ID}, ed identificato
+dall'acronimo \acr{gid}, e sono quelli che vengono usati dal kernel per
+identificare l'utente.
  
 In questo modo il sistema è in grado di tenere traccia per ogni processo
 dell'utente a cui appartiene ed impedire ad altri utenti di interferire con
diff --git a/ipc.tex b/ipc.tex
index 0c6a4f2..fca22f0 100644 (file)
--- a/ipc.tex
+++ b/ipc.tex
@@ -1057,7 +1057,7 @@ il proprietario, il suo gruppo e tutti gli altri.
 
 Quando l'oggetto viene creato i campi \var{cuid} e \var{uid} di
 \struct{ipc\_perm} ed i campi \var{cgid} e \var{gid} vengono settati
-rispettivamente al valore dell'userid e del groupid effettivo del processo che
+rispettivamente al valore dell'user-ID e del group-ID effettivo del processo che
 ha chiamato la funzione, ma, mentre i campi \var{uid} e \var{gid} possono
 essere cambiati, i campi \var{cuid} e \var{cgid} restano sempre gli stessi.
 
@@ -1077,12 +1077,12 @@ controlli 
 \begin{itemize}
 \item se il processo ha i privilegi di amministratore l'accesso è sempre
   consentito. 
-\item se l'userid effettivo del processo corrisponde o al valore del campo
+\item se l'user-ID effettivo del processo corrisponde o al valore del campo
   \var{cuid} o a quello del campo \var{uid} ed il permesso per il proprietario
   in \var{mode} è appropriato\footnote{per appropriato si intende che è
     settato il permesso di scrittura per le operazioni di scrittura e quello
     di lettura per le operazioni di lettura.} l'accesso è consentito.
-\item se il groupid effettivo del processo corrisponde o al
+\item se il group-ID effettivo del processo corrisponde o al
   valore del campo \var{cgid} o a quello del campo \var{gid} ed il permesso
   per il gruppo in \var{mode} è appropriato l'accesso è consentito.
 \item se il permesso per gli altri è appropriato l'accesso è consentito.
@@ -1456,7 +1456,7 @@ eseguire; i valori possibili sono:
   riceveranno un errore di \errcode{EIDRM}, e tutti processi in attesa su
   funzioni di di lettura o di scrittura sulla coda saranno svegliati ricevendo
   il medesimo errore. Questo comando può essere eseguito solo da un processo
-  con userid effettivo corrispondente al creatore o al proprietario della
+  con user-ID effettivo corrispondente al creatore o al proprietario della
   coda, o all'amministratore.
 \item[\const{IPC\_SET}] Permette di modificare i permessi ed il proprietario
   della coda, ed il limite massimo sulle dimensioni del totale dei messaggi in
@@ -2168,14 +2168,14 @@ seguenti:
 \item[\const{IPC\_RMID}] Rimuove l'insieme di semafori e le relative strutture
   dati, con effetto immediato. Tutti i processi che erano stato di
   \textit{sleep} vengono svegliati, ritornando con un errore di
-  \errcode{EIDRM}.  L'userid effettivo del processo deve corrispondere o al
+  \errcode{EIDRM}.  L'user-ID effettivo del processo deve corrispondere o al
   creatore o al proprietario dell'insieme, o all'amministratore. L'argomento
   \param{semnum} viene ignorato.
 \item[\const{IPC\_SET}] Permette di modificare i permessi ed il proprietario
   dell'insieme. I valori devono essere passati in una struttura
   \struct{semid\_ds} puntata da \param{arg.buf} di cui saranno usati soltanto i
   campi \var{sem\_perm.uid}, \var{sem\_perm.gid} e i nove bit meno
-  significativi di \var{sem\_perm.mode}. L'userid effettivo del processo deve
+  significativi di \var{sem\_perm.mode}. L'user-ID effettivo del processo deve
   corrispondere o al creatore o al proprietario dell'insieme, o
   all'amministratore.  L'argomento \param{semnum} viene ignorato.
 \item[\const{GETALL}] Restituisce il valore corrente di ciascun semaforo
@@ -2772,7 +2772,7 @@ attraverso l'argomento \param{cmd}, i valori possibili sono i seguenti:
 \item[\const{IPC\_RMID}] Marca il segmento di memoria condivisa per la
   rimozione, questo verrà cancellato effettivamente solo quando l'ultimo
   processo ad esso agganciato si sarà staccato. Questo comando può essere
-  eseguito solo da un processo con userid effettivo corrispondente o al
+  eseguito solo da un processo con user-ID effettivo corrispondente o al
   creatore della coda, o al proprietario della coda, o all'amministratore.
 \item[\const{IPC\_SET}] Permette di modificare i permessi ed il proprietario
   del segmento.  Per modificare i valori di \var{shm\_perm.mode},
index f29d5e3..c5f9187 100644 (file)
@@ -46,15 +46,15 @@ avvio, usando il programma \cmd{ld-linux.so}.  Questo programma prima carica
 le librerie condivise che servono al programma, poi effettua il link dinamico
 del codice e alla fine lo esegue. Infatti, a meno di non aver specificato il
 flag \texttt{-static} durante la compilazione, tutti i programmi in Linux sono
-incompleti e necessitano di essere linkati alle librerie condivise quando
-vengono avviati.  La procedura è controllata da alcune variabili di ambiente e
-dal contenuto di \file{/etc/ld.so.conf}. I dettagli sono riportati nella man
-page di \cmd{ld.so}.
+incompleti e necessitano di essere \textit{linkati} alle librerie condivise
+quando vengono avviati.  La procedura è controllata da alcune variabili di
+ambiente e dal contenuto di \file{/etc/ld.so.conf}. I dettagli sono riportati
+nella man page di \cmd{ld.so}.
 
 Il sistema fa partire qualunque programma chiamando la funzione \func{main};
 sta al programmatore chiamare così la funzione principale del programma da cui
 si suppone iniziare l'esecuzione; in ogni caso senza questa funzione lo stesso
-linker darebbe luogo ad errori.
+\textit{linker} darebbe luogo ad errori.
 
 Lo standard ISO C specifica che la funzione \func{main} può non avere 
 argomenti o prendere due argomenti che rappresentano gli argomenti passati da
@@ -80,10 +80,10 @@ automaticamente quando \func{main} ritorna).  Una forma alternativa 
 di chiamare direttamente la system call \func{\_exit}, che restituisce il
 controllo direttamente alla routine di conclusione dei processi del kernel.
 
-Oltre alla conclusione ``normale'' esiste anche la possibilità di una
-conclusione ``anomala'' del programma a causa della ricezione di un segnale
-(si veda \capref{cha:signals}) o della chiamata alla funzione \func{abort};
-torneremo su questo in \secref{sec:proc_termination}.
+Oltre alla conclusione ``\textsl{normale}'' esiste anche la possibilità di una
+conclusione ``\textsl{anomala}'' del programma a causa della ricezione di un
+segnale (si veda \capref{cha:signals}) o della chiamata alla funzione
+\func{abort}; torneremo su questo in \secref{sec:proc_termination}.
 
 Il valore di ritorno della funzione \func{main}, o quello usato nelle chiamate
 ad \func{exit} e \func{\_exit}, viene chiamato \textsl{stato di uscita} (o
@@ -124,9 +124,9 @@ valori di tipo \ctyp{int} 0 e 1.
 \subsection{Le funzioni \func{exit} e \func{\_exit}}
 \label{sec:proc_exit}
 
-Come accennato le funzioni usate per effettuare un'uscita ``normale'' da un
-programma sono due, la prima è la funzione \funcd{exit}, che è definita dallo
-standard ANSI C ed il cui prototipo è:
+Come accennato le funzioni usate per effettuare un'uscita ``\textit{normale}''
+da un programma sono due, la prima è la funzione \funcd{exit}, che è definita
+dallo standard ANSI C ed il cui prototipo è:
 \begin{prototype}{stdlib.h}{void exit(int status)}
   Causa la conclusione ordinaria del programma.
 
@@ -392,10 +392,10 @@ seguenti segmenti:
   del chiamante (tipo il contenuto di alcuni registri della CPU). Poi la
   funzione chiamata alloca qui lo spazio per le sue variabili locali: in
   questo modo le funzioni possono essere chiamate ricorsivamente. Al ritorno
-  della funzione lo spazio è automaticamente rilasciato e ``ripulito''. La
-  pulizia in C e C++ viene fatta dal chiamante.\footnote{a meno che non sia
-    stato specificato l'utilizzo di una calling convention diversa da quella
-    standard.}
+  della funzione lo spazio è automaticamente rilasciato e
+  ``\textsl{ripulito}''. La pulizia in C e C++ viene fatta dal
+  chiamante.\footnote{a meno che non sia stato specificato l'utilizzo di una
+    calling convention diversa da quella standard.}
   
   La dimensione di questo segmento aumenta seguendo la crescita dello stack
   del programma, ma non viene ridotta quando quest'ultimo si restringe.
@@ -531,7 +531,7 @@ in ingresso; per questo si dovr
 ad un adeguato aggiornamento di tutti gli altri puntatori all'interno del
 blocco di dati ridimensionato.
 
-Un errore abbastanza frequente (specie se si ha a che fare con array di
+Un errore abbastanza frequente (specie se si ha a che fare con vettori di
 puntatori) è quello di chiamare \func{free} più di una volta sullo stesso
 puntatore; per evitare questo problema una soluzione di ripiego è quella di
 assegnare sempre a \val{NULL} ogni puntatore liberato con \func{free}, dato
@@ -541,7 +541,7 @@ operazione.
 Le \acr{glibc} hanno un'implementazione delle routine di allocazione che è
 controllabile dall'utente attraverso alcune variabili di ambiente, in
 particolare diventa possibile tracciare questo tipo di errori usando la
-variabile d'ambiente \val{MALLOC\_CHECK\_} che quando viene definita mette in
+variabile dambiente \val{MALLOC\_CHECK\_} che quando viene definita mette in
 uso una versione meno efficiente delle funzioni suddette, che però è più
 tollerante nei confronti di piccoli errori come quello di chiamate doppie a
 \func{free}.  In particolare:
@@ -682,7 +682,7 @@ prima funzione 
     fallimento, nel qual caso \var{errno} assumerà il valore \errval{ENOMEM}.}
 \end{prototype}
 
-La funzione è un'interfaccia diretta all'ominima system call ed imposta
+La funzione è un'interfaccia diretta all'omonima system call ed imposta
 l'indirizzo finale del segmento dati di un processo all'indirizzo specificato
 da \param{end\_data\_segment}. Quest'ultimo deve essere un valore ragionevole,
 ed inoltre la dimensione totale del segmento non deve comunque eccedere un
@@ -691,7 +691,7 @@ dimensioni massime dello spazio dati del processo.
 
 La seconda funzione per la manipolazione delle dimensioni del segmento
 dati\footnote{in questo caso si tratta soltanto di una funzione di libreria, e
-  non di una sistem call.} è \funcd{sbrk}, ed il suo prototipo è:
+  non di una system call.} è \funcd{sbrk}, ed il suo prototipo è:
 \begin{prototype}{unistd.h}{void *sbrk(ptrdiff\_t increment)} 
   Incrementa la dimensione dello spazio dati.
   
@@ -974,10 +974,10 @@ elementi di \param{argv} che cominciano con il carattere \texttt{'-'}.
             usage();
             return -1;
             break;
-        case 'c':   /* take wait time for childen */
+        case 'c':   /* take wait time for children */
             wait_child = strtol(optarg, NULL, 10);    /* convert input */
             break;
-        case 'p':   /* take wait time for childen */
+        case 'p':   /* take wait time for children */
             wait_parent = strtol(optarg, NULL, 10);   /* convert input */
             break;
         case 'e':   /* take wait before parent exit */
@@ -1058,10 +1058,10 @@ sistema un \textsl{ambiente}, nella forma di una lista di variabili (detta
 \textit{environment list}) messa a disposizione dal processo, e costruita
 nella chiamata alla funzione \func{exec} quando questo viene lanciato.
 
-Come per la lista dei parametri anche questa lista è un array di puntatori a
+Come per la lista dei parametri anche questa lista è un vettore di puntatori a
 caratteri, ciascuno dei quali punta ad una stringa, terminata da un
 \val{NULL}. A differenza di \code{argv[]} in questo caso non si ha una
-lunghezza dell'array data da un equivalente di \param{argc}, ma la lista è
+lunghezza del vettore data da un equivalente di \param{argc}, ma la lista è
 terminata da un puntatore nullo.
 
 L'indirizzo della lista delle variabili di ambiente è passato attraverso la
@@ -1365,7 +1365,7 @@ inoltre che l'ultimo degli argomenti fissi sia di tipo
   per compatibilità; ad esempio i tipi \ctyp{float} vengono convertiti
   automaticamente a \ctyp{double} ed i \ctyp{char} e gli \ctyp{short} ad
   \ctyp{int}. Un tipo \textit{self-promoting} è un tipo che verrebbe promosso
-  a sé stesso.} il che esclude array, puntatori a funzioni e interi di tipo
+  a sé stesso.} il che esclude vettori, puntatori a funzioni e interi di tipo
 \ctyp{char} o \ctyp{short} (con segno o meno). Una restrizione ulteriore di
 alcuni compilatori è di non dichiarare l'ultimo parametro fisso come
 \ctyp{register}.
index 9321232..bddc07a 100644 (file)
@@ -43,7 +43,7 @@ caratteristiche di Unix (che esamineremo in dettaglio pi
 qualunque processo può a sua volta generarne altri, detti processi figli
 (\textit{child process}). Ogni processo è identificato presso il sistema da un
 numero univoco, il cosiddetto \textit{process identifier} o, più brevemente,
-\acr{pid}, assengnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
+\acr{pid}, assegnato in forma progressiva (vedi \secref{sec:proc_pid}) quando
 il processo viene creato.
 
 Una seconda caratteristica di un sistema Unix è che la generazione di un
@@ -223,7 +223,7 @@ programmi.
 \label{sec:proc_pid}
 
 Come accennato nell'introduzione, ogni processo viene identificato dal sistema
-da un numero identificativo univoco, il \textit{process id} o \acr{pid};
+da un numero identificativo univoco, il \textit{process ID} o \acr{pid};
 quest'ultimo è un tipo di dato standard, il \type{pid\_t} che in genere è un
 intero con segno (nel caso di Linux e delle \acr{glibc} il tipo usato è
 \ctyp{int}).
@@ -246,7 +246,7 @@ sempre il \acr{pid} uguale a uno.
 
 Tutti i processi inoltre memorizzano anche il \acr{pid} del genitore da cui
 sono stati creati, questo viene chiamato in genere \acr{ppid} (da
-\textit{parent process id}).  Questi due identificativi possono essere
+\textit{parent process ID}).  Questi due identificativi possono essere
 ottenuti usando le due funzioni \funcd{getpid} e \funcd{getppid}, i cui
 prototipi sono:
 \begin{functions}
@@ -317,7 +317,7 @@ prototipo della funzione 
 
 Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che
 il processo figlio continuano ad essere eseguiti normalmente a partire
-dall'istruzione seccessiva alla \func{fork}; il processo figlio è però una
+dall'istruzione successiva alla \func{fork}; il processo figlio è però una
 copia del padre, e riceve una copia dei segmenti di testo, stack e dati (vedi
 \secref{sec:proc_mem_layout}), ed esegue esattamente lo stesso codice del
 padre. Si tenga presente però che la memoria è copiata, non condivisa,
@@ -628,12 +628,12 @@ comune dopo l'esecuzione di una \func{fork} 
 \item i file aperti e gli eventuali flag di
   \textit{close-on-exec}\index{close-on-exec} impostati (vedi
   \secref{sec:proc_exec} e \secref{sec:file_fcntl}).
-\item gli identificatori per il controllo di accesso: l'\textsl{userid reale},
-  il \textsl{groupid reale}, l'\textsl{userid effettivo}, il \textsl{groupid
-    effettivo} ed i \textit{groupid supplementari} (vedi
+\item gli identificatori per il controllo di accesso: l'\textsl{user-ID
+    reale}, il \textsl{group-ID reale}, l'\textsl{user-ID effettivo}, il
+  \textsl{group-ID effettivo} ed i \textit{group-ID supplementari} (vedi
   \secref{sec:proc_access_id}).
 \item gli identificatori per il controllo di sessione: il \textit{process
-    groupid} e il \textit{session id} ed il terminale di controllo (vedi
+    group-ID} e il \textit{session id} ed il terminale di controllo (vedi
   \secref{sec:sess_proc_group}).
 \item la directory di lavoro e la directory radice (vedi
   \secref{sec:file_work_dir} e \secref{sec:file_chroot}).
@@ -1240,9 +1240,9 @@ la lista completa 
 \begin{itemize*}
 \item il \textit{process id} (\acr{pid}) ed il \textit{parent process id}
   (\acr{ppid}).
-\item l'\textsl{userid reale}, il \textit{groupid reale} ed i \textsl{groupid
-    supplementari} (vedi \secref{sec:proc_access_id}).
-\item il \textit{session id} (\acr{sid}) ed il \textit{process groupid}
+\item l'\textsl{user-ID reale}, il \textit{group-ID reale} ed i
+  \textsl{group-ID supplementari} (vedi \secref{sec:proc_access_id}).
+\item il \textit{session id} (\acr{sid}) ed il \textit{process group-ID}
   (\acr{pgid}), vedi \secref{sec:sess_proc_group}.
 \item il terminale di controllo (vedi \secref{sec:sess_ctrl_term}).
 \item il tempo restante ad un allarme (vedi \secref{sec:sig_alarm_abort}).
@@ -1279,14 +1279,14 @@ attraverso una \func{exec}, in genere questo 
 l'impostazione del flag di \textit{close-on-exec}\index{close-on-exec} sulle
 directory che apre, in maniera trasparente all'utente.
 
-Abbiamo detto che l'\textsl{userid reale} ed il \textsl{groupid reale} restano
-gli stessi all'esecuzione di \func{exec}; lo stesso vale per l'\textsl{userid
-  effettivo} ed il \textsl{groupid effettivo} (il significato di questi
-identificatori è trattato in \secref{sec:proc_access_id}), tranne quando il
-file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid} bit
-impostato, in questo caso l'\textsl{userid effettivo} ed il \textsl{groupid
-  effettivo} vengono impostati rispettivamente all'utente o al gruppo cui il
-file appartiene (per i dettagli vedi \secref{sec:proc_perms}).
+Abbiamo detto che l'\textsl{user-ID reale} ed il \textsl{group-ID reale}
+restano gli stessi all'esecuzione di \func{exec}; lo stesso vale per
+l'\textsl{user-ID effettivo} ed il \textsl{group-ID effettivo} (il significato
+di questi identificatori è trattato in \secref{sec:proc_access_id}), tranne
+quando il file che si va ad eseguire abbia o il \acr{suid} bit o lo \acr{sgid}
+bit impostato, in questo caso l'\textsl{user-ID effettivo} ed il
+\textsl{group-ID effettivo} vengono impostati rispettivamente all'utente o al
+gruppo cui il file appartiene (per i dettagli vedi \secref{sec:proc_perms}).
 
 Se il file da eseguire è in formato \emph{a.out} e necessita di librerie
 condivise, viene lanciato il \textit{linker} dinamico \cmd{ld.so} prima del
@@ -1329,7 +1329,7 @@ Come accennato in \secref{sec:intro_multiuser} il modello base\footnote{in
   o il \textit{Mandatory Access Control} di SELinux; inoltre basandosi sul
   lavoro effettuato con SELinux, a partire dal kernel 2.5.x, è iniziato lo
   sviluppo di una infrastruttura di sicurezza, il \textit{Linux Security
-    Modules}, ol LSM, in grado di fornire diversi agganci a livello del kernel
+    Modules}, o LSM, in grado di fornire diversi agganci a livello del kernel
   per modularizzare tutti i possibili controlli di accesso.} di sicurezza di
 un sistema unix-like è fondato sui concetti di utente e gruppo, e sulla
 separazione fra l'amministratore (\textsl{root}, detto spesso anche
@@ -1341,7 +1341,7 @@ utenti, per i quali invece vengono effettuati i vari controlli di accesso.
 %notevole flessibilità, 
 
 Abbiamo già accennato come il sistema associ ad ogni utente e gruppo due
-identificatori univoci, lo userid ed il groupid; questi servono al kernel per
+identificatori univoci, lo user-ID ed il group-ID; questi servono al kernel per
 identificare uno specifico utente o un gruppo di utenti, per poi poter
 controllare che essi siano autorizzati a compiere le operazioni richieste.  Ad
 esempio in \secref{sec:file_access_control} vedremo come ad ogni file vengano
@@ -1373,27 +1373,27 @@ rispettivamente \textit{real} ed \textit{effective} (cio
                                         & \textbf{Significato} \\ 
     \hline
     \hline
-    \acr{uid}   & \textit{real} & \textsl{userid reale} 
+    \acr{uid}   & \textit{real} & \textsl{user-ID reale} 
                 & indica l'utente che ha lanciato il programma\\ 
-    \acr{gid}   & '' &\textsl{groupid reale} 
+    \acr{gid}   & '' &\textsl{group-ID reale} 
                 & indica il gruppo principale dell'utente che ha lanciato 
                   il programma \\ 
     \hline
-    \acr{euid}  & \textit{effective} &\textsl{userid effettivo} 
+    \acr{euid}  & \textit{effective} &\textsl{user-ID effettivo} 
                 & indica l'utente usato nel controllo di accesso \\ 
-    \acr{egid}  & '' & \textsl{groupid effettivo} 
+    \acr{egid}  & '' & \textsl{group-ID effettivo} 
                 & indica il gruppo usato nel controllo di accesso \\ 
-    --          & -- & \textsl{groupid supplementari} 
+    --          & -- & \textsl{group-ID supplementari} 
                 & indicano gli ulteriori gruppi cui l'utente appartiene \\ 
     \hline
-    --          & \textit{saved} & \textsl{userid salvato} 
+    --          & \textit{saved} & \textsl{user-ID salvato} 
                 & è una copia dell'\acr{euid} iniziale\\ 
-    --          & '' & \textsl{groupid salvato} 
+    --          & '' & \textsl{group-ID salvato} 
                 & è una copia dell'\acr{egid} iniziale \\ 
     \hline
-    \acr{fsuid} & \textit{filesystem} &\textsl{userid di filesystem} 
+    \acr{fsuid} & \textit{filesystem} &\textsl{user-ID di filesystem} 
                 & indica l'utente effettivo per l'accesso al filesystem \\ 
-    \acr{fsgid} & '' & \textsl{groupid di filesystem} 
+    \acr{fsgid} & '' & \textsl{group-ID di filesystem} 
                 & indica il gruppo effettivo per l'accesso al filesystem  \\ 
     \hline
   \end{tabular}
@@ -1402,7 +1402,7 @@ rispettivamente \textit{real} ed \textit{effective} (cio
   \label{tab:proc_uid_gid}
 \end{table}
 
-Al primo gruppo appartengono l'\textsl{userid reale} ed il \textsl{groupid
+Al primo gruppo appartengono l'\textsl{user-ID reale} ed il \textsl{group-ID
   reale}: questi vengono impostati al login ai valori corrispondenti
 all'utente con cui si accede al sistema (e relativo gruppo principale).
 Servono per l'identificazione dell'utente e normalmente non vengono mai
@@ -1413,8 +1413,8 @@ completata la procedura di autenticazione, lancia una shell per la quale
 imposta questi identificatori ai valori corrispondenti all'utente che entra
 nel sistema.
 
-Al secondo gruppo appartengono lo \textsl{userid effettivo} ed il
-\textsl{groupid effettivo} (a cui si aggiungono gli eventuali \textsl{groupid
+Al secondo gruppo appartengono lo \textsl{user-ID effettivo} ed il
+\textsl{group-ID effettivo} (a cui si aggiungono gli eventuali \textsl{group-ID
   supplementari} dei gruppi dei quali l'utente fa parte).  Questi sono invece
 gli identificatori usati nella verifiche dei permessi del processo e per il
 controllo di accesso ai file (argomento affrontato in dettaglio in
@@ -1436,16 +1436,16 @@ prototipi sono:
 \begin{functions}
   \headdecl{unistd.h}
   \headdecl{sys/types.h}  
-  \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{userid reale} del
+  \funcdecl{uid\_t getuid(void)} Restituisce l'\textsl{user-ID reale} del
   processo corrente.
 
-  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{userid effettivo} del
+  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textsl{user-ID effettivo} del
   processo corrente.
 
-  \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{groupid reale} del
+  \funcdecl{gid\_t getgid(void)} Restituisce il \textsl{group-ID reale} del
   processo corrente.
   
-  \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{groupid effettivo}
+  \funcdecl{gid\_t getegid(void)} Restituisce il \textsl{group-ID effettivo}
   del processo corrente.
   
   \bodydesc{Queste funzioni non riportano condizioni di errore.}
@@ -1467,15 +1467,15 @@ costante \macro{\_POSIX\_SAVED\_IDS},\footnote{in caso si abbia a cuore la
   definita.} il secondo gruppo è specifico di Linux e viene usato per
 migliorare la sicurezza con NFS.
 
-L'\textsl{userid salvato} ed il \textsl{groupid salvato} sono copie
-dell'\textsl{userid effettivo} e del \textsl{groupid effettivo} del processo
+L'\textsl{user-ID salvato} ed il \textsl{group-ID salvato} sono copie
+dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo} del processo
 padre, e vengono impostati dalla funzione \func{exec} all'avvio del processo,
-come copie dell'\textsl{userid effettivo} e del \textsl{groupid effettivo}
+come copie dell'\textsl{user-ID effettivo} e del \textsl{group-ID effettivo}
 dopo che questo sono stati impostati tenendo conto di eventuali \acr{suid} o
 \acr{sgid}.  Essi quindi consentono di tenere traccia di quale fossero utente
 e gruppo effettivi all'inizio dell'esecuzione di un nuovo programma.
 
-L'\textsl{userid di filesystem} e il \textsl{groupid di filesystem} sono
+L'\textsl{user-ID di filesystem} e il \textsl{group-ID di filesystem} sono
 un'estensione introdotta in Linux per rendere più sicuro l'uso di NFS
 (torneremo sull'argomento in \secref{sec:proc_setfsuid}). Essi sono una
 replica dei corrispondenti identificatori del gruppo \textit{effective}, ai
@@ -1492,16 +1492,16 @@ ignorarne l'esistenza, in quanto saranno del tutto equivalenti ai precedenti.
 Le due funzioni che vengono usate per cambiare identità (cioè utente e gruppo
 di appartenenza) ad un processo sono rispettivamente \funcd{setuid} e
 \funcd{setgid}; come accennato in \secref{sec:proc_access_id} in Linux esse
-seguono la semantica POSIX che prevede l'esistenza dell'\textit{userid
-  salvato} e del \textit{groupid salvato}; i loro prototipi sono:
+seguono la semantica POSIX che prevede l'esistenza dell'\textit{user-ID
+  salvato} e del \textit{group-ID salvato}; i loro prototipi sono:
 \begin{functions}
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{userid} del processo
+\funcdecl{int setuid(uid\_t uid)} Imposta l'\textsl{user-ID} del processo
 corrente.
 
-\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{groupid} del processo
+\funcdecl{int setgid(gid\_t gid)} Imposta il \textsl{group-ID} del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1510,21 +1510,21 @@ corrente.
 
 Il funzionamento di queste due funzioni è analogo, per cui considereremo solo
 la prima; la seconda si comporta esattamente allo stesso modo facendo
-riferimento al \textsl{groupid} invece che all'\textsl{userid}.  Gli
-eventuali \textsl{groupid supplementari} non vengono modificati.
+riferimento al \textsl{group-ID} invece che all'\textsl{user-ID}.  Gli
+eventuali \textsl{group-ID supplementari} non vengono modificati.
 
 L'effetto della chiamata è diverso a seconda dei privilegi del processo; se
-l'\textsl{userid effettivo} è zero (cioè è quello dell'amministratore di
+l'\textsl{user-ID effettivo} è zero (cioè è quello dell'amministratore di
 sistema) allora tutti gli identificatori (\textit{real}, \textit{effective} e
 \textit{saved}) vengono impostati al valore specificato da \param{uid},
-altrimenti viene impostato solo l'\textsl{userid effettivo}, e soltanto se il
-valore specificato corrisponde o all'\textsl{userid reale} o
-all'\textsl{userid salvato}. Negli altri casi viene segnalato un errore (con
+altrimenti viene impostato solo l'\textsl{user-ID effettivo}, e soltanto se il
+valore specificato corrisponde o all'\textsl{user-ID reale} o
+all'\textsl{user-ID salvato}. Negli altri casi viene segnalato un errore (con
 \errcode{EPERM}).
 
 Come accennato l'uso principale di queste funzioni è quello di poter
 consentire ad un programma con i bit \acr{suid} o \acr{sgid} impostati (vedi
-\secref{sec:file_suid_sgid}) di riportare l'\textsl{userid effettivo} a quello
+\secref{sec:file_suid_sgid}) di riportare l'\textsl{user-ID effettivo} a quello
 dell'utente che ha lanciato il programma, effettuare il lavoro che non
 necessita di privilegi aggiuntivi, ed eventualmente tornare indietro.
 
@@ -1543,35 +1543,35 @@ Quando uno di questi programmi (ad esempio \cmd{xterm}) viene lanciato, la
 situazione degli identificatori è la seguente:
 \begin{eqnarray*}
   \label{eq:1}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (del chiamante)} \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp}}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (del chiamante)} \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp}}
 \end{eqnarray*}
-in questo modo, dato che il \textsl{groupid effettivo} è quello giusto, il
+in questo modo, dato che il \textsl{group-ID effettivo} è quello giusto, il
 programma può accedere a \file{/var/log/utmp} in scrittura ed aggiornarlo. A
 questo punto il programma può eseguire una \code{setgid(getgid())} per
-impostare il \textsl{groupid effettivo} a quello dell'utente (e dato che il
-\textsl{groupid reale} corrisponde la funzione avrà successo), in questo modo
+impostare il \textsl{group-ID effettivo} a quello dell'utente (e dato che il
+\textsl{group-ID reale} corrisponde la funzione avrà successo), in questo modo
 non sarà possibile lanciare dal terminale programmi che modificano detto file,
 in tal caso infatti la situazione degli identificatori sarebbe:
 \begin{eqnarray*}
   \label{eq:2}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{gid}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{gid}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 e ogni processo lanciato dal terminale avrebbe comunque \acr{gid} come
-\textsl{groupid effettivo}. All'uscita dal terminale, per poter di nuovo
+\textsl{group-ID effettivo}. All'uscita dal terminale, per poter di nuovo
 aggiornare lo stato di \file{/var/log/utmp} il programma eseguirà una
 \code{setgid(utmp)} (dove \var{utmp} è il valore numerico associato al gruppo
 \acr{utmp}, ottenuto ad esempio con una precedente \func{getegid}), dato che
-in questo caso il valore richiesto corrisponde al \textsl{groupid salvato} la
+in questo caso il valore richiesto corrisponde al \textsl{group-ID salvato} la
 funzione avrà successo e riporterà la situazione a:
 \begin{eqnarray*}
   \label{eq:3}
-  \textsl{groupid reale}      &=& \textrm{\acr{gid} (invariato)}  \\
-  \textsl{groupid effettivo}  &=& \textrm{\acr{utmp}} \\
-  \textsl{groupid salvato}    &=& \textrm{\acr{utmp} (invariato)}
+  \textsl{group-ID reale}      &=& \textrm{\acr{gid} (invariato)}  \\
+  \textsl{group-ID effettivo}  &=& \textrm{\acr{utmp}} \\
+  \textsl{group-ID salvato}    &=& \textrm{\acr{utmp} (invariato)}
 \end{eqnarray*}
 consentendo l'accesso a \file{/var/log/utmp}.
 
@@ -1581,7 +1581,7 @@ comporta il cambiamento di tutti gli identificatori associati al processo,
 rendendo impossibile riguadagnare i privilegi di amministratore.  Questo
 comportamento è corretto per l'uso che ne fa \cmd{login} una volta che crea
 una nuova shell per l'utente; ma quando si vuole cambiare soltanto
-l'\textsl{userid effettivo} del processo per cedere i privilegi occorre
+l'\textsl{user-ID effettivo} del processo per cedere i privilegi occorre
 ricorrere ad altre funzioni (si veda ad esempio \secref{sec:proc_seteuid}).
 
 
@@ -1596,12 +1596,12 @@ loro \textit{effective} e \textit{real}. I loro prototipi sono:
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{userid
-  reale} e l'\textsl{userid effettivo} del processo corrente ai valori
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Imposta l'\textsl{user-ID
+  reale} e l'\textsl{user-ID effettivo} del processo corrente ai valori
 specificati da \param{ruid} e \param{euid}.
   
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{groupid
-  reale} ed il \textsl{groupid effettivo} del processo corrente ai valori
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Imposta il \textsl{group-ID
+  reale} ed il \textsl{group-ID effettivo} del processo corrente ai valori
 specificati da \param{rgid} e \param{egid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1609,14 +1609,14 @@ specificati da \param{rgid} e \param{egid}.
 \end{functions}
 
 La due funzioni sono analoghe ed il loro comportamento è identico; quanto
-detto per la prima prima riguardo l'userid, si applica immediatamente alla
-seconda per il groupid. I processi non privilegiati possono impostare solo i
-valori del loro userid effettivo o reale; valori diversi comportano il
+detto per la prima prima riguardo l'user-ID, si applica immediatamente alla
+seconda per il group-ID. I processi non privilegiati possono impostare solo i
+valori del loro user-ID effettivo o reale; valori diversi comportano il
 fallimento della chiamata; l'amministratore invece può specificare un valore
 qualunque.  Specificando un argomento di valore -1 l'identificatore
 corrispondente verrà lasciato inalterato.
 
-Con queste funzioni si possono scambiare fra loro gli userid reale e
+Con queste funzioni si possono scambiare fra loro gli user-ID reale e
 effettivo, e pertanto è possibile implementare un comportamento simile a
 quello visto in precedenza per \func{setgid}, cedendo i privilegi con un primo
 scambio, e recuperandoli, eseguito il lavoro non privilegiato, con un secondo
@@ -1624,20 +1624,20 @@ scambio.
 
 In questo caso però occorre porre molta attenzione quando si creano nuovi
 processi nella fase intermedia in cui si sono scambiati gli identificatori, in
-questo caso infatti essi avranno un userid reale privilegiato, che dovrà
+questo caso infatti essi avranno un user-ID reale privilegiato, che dovrà
 essere esplicitamente eliminato prima di porre in esecuzione un nuovo
 programma (occorrerà cioè eseguire un'altra chiamata dopo la \func{fork} e
-prima della \func{exec} per uniformare l'userid reale a quello effettivo) in
+prima della \func{exec} per uniformare l'user-ID reale a quello effettivo) in
 caso contrario il nuovo programma potrebbe a sua volta effettuare uno scambio
 e riottenere privilegi non previsti.
 
 Lo stesso problema di propagazione dei privilegi ad eventuali processi figli
-si pone per l'userid salvato: questa funzione deriva da un'implementazione che
+si pone per l'user-ID salvato: questa funzione deriva da un'implementazione che
 non ne prevede la presenza, e quindi non è possibile usarla per correggere la
 situazione come nel caso precedente. Per questo motivo in Linux tutte le volte
-che si imposta un qualunque valore diverso da quello dall'userid reale
-corrente, l'userid salvato viene automaticamente uniformato al valore
-dell'userid effettivo.
+che si imposta un qualunque valore diverso da quello dall'user-ID reale
+corrente, l'user-ID salvato viene automaticamente uniformato al valore
+dell'user-ID effettivo.
 
 
 \subsection{Le funzioni \funcd{seteuid} e \funcd{setegid}}
@@ -1650,10 +1650,10 @@ identificatori del gruppo \textit{effective}; i loro prototipi sono:
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int seteuid(uid\_t uid)} Imposta l'userid effettivo del processo
+\funcdecl{int seteuid(uid\_t uid)} Imposta l'user-ID effettivo del processo
 corrente a \param{uid}.
 
-\funcdecl{int setegid(gid\_t gid)} Imposta il groupid effettivo del processo
+\funcdecl{int setegid(gid\_t gid)} Imposta il group-ID effettivo del processo
 corrente a \param{gid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1661,10 +1661,10 @@ corrente a \param{gid}.
 \end{functions}
 
 Come per le precedenti le due funzioni sono identiche, per cui tratteremo solo
-la prima. Gli utenti normali possono impostare l'userid effettivo solo al
-valore dell'userid reale o dell'userid salvato, l'amministratore può
+la prima. Gli utenti normali possono impostare l'user-ID effettivo solo al
+valore dell'user-ID reale o dell'user-ID salvato, l'amministratore può
 specificare qualunque valore. Queste funzioni sono usate per permettere
-all'amministratore di impostare solo l'userid effettivo, dato che l'uso
+all'amministratore di impostare solo l'user-ID effettivo, dato che l'uso
 normale di \func{setuid} comporta l'impostazione di tutti gli identificatori.
  
 
@@ -1679,12 +1679,12 @@ e permettono un completo controllo su tutti gli identificatori (\textit{real},
 \headdecl{sys/types.h}
 
 \funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Imposta
-l'userid reale, l'userid effettivo e l'userid salvato del processo corrente ai
-valori specificati rispettivamente da \param{ruid}, \param{euid} e
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente
+ai valori specificati rispettivamente da \param{ruid}, \param{euid} e
 \param{suid}.
   
 \funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Imposta il
-groupid reale, il groupid effettivo ed il groupid salvato del processo
+group-ID reale, il group-ID effettivo ed il group-ID salvato del processo
 corrente ai valori specificati rispettivamente da \param{rgid}, \param{egid} e
 \param{sgid}.
 
@@ -1692,10 +1692,10 @@ corrente ai valori specificati rispettivamente da \param{rgid}, \param{egid} e
   di fallimento: l'unico errore è \errval{EPERM}.}
 \end{functions}
 
-Le due funzioni sono identiche, quanto detto per la prima riguardo gli userid
-si applica alla seconda per i groupid. I processi non privilegiati possono
-cambiare uno qualunque degli userid solo ad un valore corripondente o
-all'userid reale, o a quello effettivo o a quello salvato, l'amministratore
+Le due funzioni sono identiche, quanto detto per la prima riguardo gli user-ID
+si applica alla seconda per i group-ID. I processi non privilegiati possono
+cambiare uno qualunque degli user-ID solo ad un valore corrispondente o
+all'user-ID reale, o a quello effettivo o a quello salvato, l'amministratore
 può specificare i valori che vuole; un valore di -1 per un qualunque parametro
 lascia inalterato l'identificatore corrispondente.
 
@@ -1707,10 +1707,10 @@ prototipi sono:
 \headdecl{sys/types.h}
 
 \funcdecl{int getresuid(uid\_t *ruid, uid\_t *euid, uid\_t *suid)} Legge
-l'userid reale, l'userid effettivo e l'userid salvato del processo corrente.
+l'user-ID reale, l'user-ID effettivo e l'user-ID salvato del processo corrente.
   
 \funcdecl{int getresgid(gid\_t *rgid, gid\_t *egid, gid\_t *sgid)} Legge il
-groupid reale, il groupid effettivo e il groupid salvato del processo
+group-ID reale, il group-ID effettivo e il group-ID salvato del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso di
@@ -1740,10 +1740,10 @@ identificatori dei gruppi \textit{effective} e \textit{filesystem}, ed 
 ovviare ad un problema di sicurezza che si presenta quando si deve
 implementare un server NFS. Il server NFS infatti deve poter cambiare
 l'identificatore con cui accede ai file per assumere l'identità del singolo
-utente remoto, ma se questo viene fatto cambiando l'userid effettivo o
-l'userid reale il server si espone alla ricezione di eventuali segnali ostili
+utente remoto, ma se questo viene fatto cambiando l'user-ID effettivo o
+l'user-ID reale il server si espone alla ricezione di eventuali segnali ostili
 da parte dell'utente di cui ha temporaneamente assunto l'identità.  Cambiando
-solo l'userid di filesystem si ottengono i privilegi necessari per accedere ai
+solo l'user-ID di filesystem si ottengono i privilegi necessari per accedere ai
 file, mantenendo quelli originari per quanto riguarda tutti gli altri
 controlli di accesso, così che l'utente non possa inviare segnali al server
 NFS.
@@ -1754,10 +1754,10 @@ usate se si intendono scrivere programmi portabili; i loro prototipi sono:
 \begin{functions}
 \headdecl{sys/fsuid.h}
 
-\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'userid di filesystem del
+\funcdecl{int setfsuid(uid\_t fsuid)} Imposta l'user-ID di filesystem del
 processo corrente a \param{fsuid}.
 
-\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il groupid di filesystem del
+\funcdecl{int setfsgid(gid\_t fsgid)} Imposta il group-ID di filesystem del
 processo corrente a \param{fsgid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1800,7 +1800,7 @@ prototipo 
 
 La funzione legge gli identificatori dei gruppi supplementari del processo sul
 vettore \param{list} di dimensione \param{size}. Non è specificato se la
-funzione inserisca o meno nella lista il groupid effettivo del processo. Se si
+funzione inserisca o meno nella lista il group-ID effettivo del processo. Se si
 specifica un valore di \param{size} uguale a 0 \param{list} non viene
 modificato, ma si ottiene il numero di gruppi supplementari.
 
@@ -2151,10 +2151,10 @@ La funzione imposta la priorit
 tutti i processi indicati dagli argomenti \param{which} e \param{who}.  La
 gestione dei permessi dipende dalle varie implementazioni; in Linux, secondo
 le specifiche dello standard SUSv3, e come avviene per tutti i sistemi che
-derivano da SYSV, è richiesto che l'userid reale o effettivo del processo
+derivano da SYSV, è richiesto che l'user-ID reale o effettivo del processo
 chiamante corrispondano al real user id (e solo quello) del processo di cui si
 vuole cambiare la priorità; per i sistemi derivati da BSD invece (SunOS,
-Ultrix, *BSD) la corrispondenza può essere anche con l'userid effettivo.
+Ultrix, *BSD) la corrispondenza può essere anche con l'user-ID effettivo.
 
 
 
@@ -2502,13 +2502,13 @@ eseguita dall'altro.
 
 
 L'esempio tipico di una situazione che può condurre ad un
-\textit{deadlock}\index{deadlock} è quello in cui un flag di ``occupazione''
-viene rilasciato da un evento asincrono (come un segnale o un altro processo)
-fra il momento in cui lo si è controllato (trovandolo occupato) e la
-successiva operazione di attesa per lo sblocco. In questo caso, dato che
-l'evento di sblocco del flag è avvenuto senza che ce ne accorgessimo proprio
-fra il controllo e la messa in attesa, quest'ultima diventerà perpetua (da cui
-il nome di \textit{deadlock}\index{deadlock}).
+\textit{deadlock}\index{deadlock} è quello in cui un flag di
+``\textsl{occupazione}'' viene rilasciato da un evento asincrono (come un
+segnale o un altro processo) fra il momento in cui lo si è controllato
+(trovandolo occupato) e la successiva operazione di attesa per lo sblocco. In
+questo caso, dato che l'evento di sblocco del flag è avvenuto senza che ce ne
+accorgessimo proprio fra il controllo e la messa in attesa, quest'ultima
+diventerà perpetua (da cui il nome di \textit{deadlock}\index{deadlock}).
 
 In tutti questi casi è di fondamentale importanza il concetto di atomicità
 visto in \secref{sec:proc_atom_oper}; questi problemi infatti possono essere
index 9bff74f..1080139 100644 (file)
@@ -560,8 +560,8 @@ valori per le variabili di ambiente, come \texttt{HOME}, \texttt{SHELL}, ecc.
 Infine attraverso l'uso di \func{setuid}, \func{setpid} e \func{initgroups}
 verrà cambiata l'identità del proprietario del processo, infatti, come
 spiegato in \secref{sec:proc_setuid}, avendo invocato tali funzioni con i
-privilegi di amministratore, tutti gli userid ed i groupid (reali, effettivi e
-salvati) saranno settati a quelli dell'utente.
+privilegi di amministratore, tutti gli user-ID ed i group-ID (reali, effettivi
+salvati) saranno settati a quelli dell'utente.
 
 A questo punto \cmd{login} provvederà (fatte salve eventuali altre azioni
 iniziali, come la stampa di messaggi di benvenuto o il controllo della posta)
index 9b90669..2e30498 100644 (file)
@@ -1037,8 +1037,8 @@ e che permette di inviare un segnale a tutto un \textit{process group} (vedi
 \secref{sec:sess_proc_group}).
 
 Solo l'amministratore può inviare un segnale ad un processo qualunque, in
-tutti gli altri casi l'userid reale o l'userid effettivo del processo
-chiamante devono corrispondere all'userid reale o all'userid salvato della
+tutti gli altri casi l'user-ID reale o l'user-ID effettivo del processo
+chiamante devono corrispondere all'user-ID reale o all'user-ID salvato della
 destinazione. Fa eccezione il caso in cui il segnale inviato sia
 \const{SIGCONT}, nel quale occorre che entrambi i processi appartengano alla
 stessa sessione. Inoltre, dato il ruolo fondamentale che riveste nel sistema
index 43c4905..b93fc88 100644 (file)
@@ -204,7 +204,7 @@ protocolli disponibili sono riportate in \tabref{tab:net_pf_names}.
 
 Non tutte le famiglie di protocolli sono accessibili dall'utente generico, ad
 esempio in generale tutti i socket di tipo \const{SOCK\_RAW} possono essere
-creati solo da processi che hanno i privilegi di root (cioè con userid
+creati solo da processi che hanno i privilegi di root (cioè con user-ID
 effettivo uguale a zero) o con la capability \texttt{CAP\_NET\_RAW}.
 
 
@@ -432,7 +432,7 @@ porta viene impostato al numero di protocollo.
 Il membro \var{sin\_family} deve essere sempre impostato; \var{sin\_port}
 specifica il numero di porta (vedi \secref{sec:TCPel_port_num}; i numeri di
 porta sotto il 1024 sono chiamati \textsl{riservati} in quanto utilizzati da
-servizi standard. Soltanto processi con i privilegi di root (con userid
+servizi standard. Soltanto processi con i privilegi di root (con user-ID
 effettivo uguale a zero) o con la capability \texttt{CAP\_NET\_BIND\_SERVICE}
 possono usare la funzione \func{bind} su queste porte.