Risistemati i prototipi delle funzioni, adesso dovrebbero essere un
authorSimone Piccardi <piccardi@gnulinux.it>
Thu, 13 Dec 2001 18:24:15 +0000 (18:24 +0000)
committerSimone Piccardi <piccardi@gnulinux.it>
Thu, 13 Dec 2001 18:24:15 +0000 (18:24 +0000)
po' piu` leggibili.

elemtcp.tex
filedir.tex
filestd.tex
fileunix.tex
network.tex
process.tex
prochand.tex
signal.tex
socket.tex
system.tex

index effafc3..f092de0 100644 (file)
@@ -640,17 +640,17 @@ ci si porr
   a \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
   l'indirizzo (locale) del socket e la dimensione della struttura che lo
   contiene, secondo quanto già trattato in \secref{sec:sock_sockaddr}.
-
-  La funzione restituisce zero in caso di successo e -1 per un errore; in caso
-  di errore la variabile \var{errno} viene settata secondo i seguenti
-  codici di errore:
+  
+  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+    errore; in caso di errore la variabile \var{errno} viene settata secondo i
+    seguenti codici di errore:
   \begin{errlist}
-  \item \macro{EBADF} il file descriptor non è valido.
-  \item \macro{EINVAL} il socket ha già un indirizzo assegnato.
-  \item \macro{ENOTSOCK} il file descriptor non è associato ad un socket.
-  \item \macro{EACCESS} si è cercato di usare una porta riservata senza
+  \item[\macro{EBADF}] il file descriptor non è valido.
+  \item[\macro{EINVAL}] il socket ha già un indirizzo assegnato.
+  \item[\macro{ENOTSOCK}] il file descriptor non è associato ad un socket.
+  \item[\macro{EACCESS}] si è cercato di usare una porta riservata senza
     sufficienti privilegi. 
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 
 Con il TCP la chiamata \func{bind} permette di specificare l'indirizzo, la
@@ -686,7 +686,7 @@ un'assegnazione immediata del tipo:
 
 \footnotesize
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
-  serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
+    serv_add.sin_addr.s_addr = htonl(INADDR_ANY);   /* connect from anywhere */
 \end{lstlisting}
 \normalsize
 
@@ -706,9 +706,10 @@ Per questo nell'header \file{netinet/in.h} 
 \type{in6addr\_any} (dichiarata come \type{extern}, ed inizializzata dal
 sistema al valore \macro{IN6ADRR\_ANY\_INIT}) che permette di effettuare una
 assegnazione del tipo: 
+
 \footnotesize
 \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
-   serv_add.sin6_addr = in6addr_any;   /* connect from anywhere */
+    serv_add.sin6_addr = in6addr_any;   /* connect from anywhere */
 \end{lstlisting}
 \normalsize
 
@@ -725,30 +726,28 @@ connessione con un server TCP, il prototipo della funzione 
   a \func{socket}, mentre il secondo e terzo argomento sono rispettivamente
   l'indirizzo e la dimensione della struttura che contiene l'indirizzo del
   socket, già descritta in \secref{sec:sock_sockaddr}.
-
-  La funzione restituisce zero in caso di successo e -1 per un errore, in caso
-  di errore la variabile \var{errno} viene settata secondo i seguenti
-  codici di errore:
+  
+  \bodydesc{La funzione restituisce zero in caso di successo e -1 per un
+    errore, in caso di errore la variabile \var{errno} viene settata secondo i
+    seguenti codici di errore:
   \begin{errlist}
-  \item \macro{EISCONN} il socket è già connesso.
-  \item \macro{ECONNREFUSED} non c'è nessuno in ascolto sull'indirizzo remoto.
-  \item \macro{ETIMEDOUT} si è avuto timeout durante il tentativo di
+  \item[\macro{ECONNREFUSED}] non c'è nessuno in ascolto sull'indirizzo remoto.
+  \item[\macro{ETIMEDOUT}] si è avuto timeout durante il tentativo di
     connessione.
-  \item \macro{ENETUNREACH} la rete non è raggiungibile.
-  \item \macro{EADDRINUSE} l'indirizzo locale è in uso.
-  \item \macro{EINPROGRESS} il socket è non bloccante e la connessione non
+  \item[\macro{ENETUNREACH}] la rete non è raggiungibile.
+  \item[\macro{EINPROGRESS}] il socket è non bloccante e la connessione non
     può essere conclusa immediatamente.
-  \item \macro{EALREADY} il socket è non bloccante e un tentativo precedente
+  \item[\macro{EALREADY}] il socket è non bloccante e un tentativo precedente
     di connessione non si è ancora concluso.
-  \item \macro{EAGAIN} non ci sono più porte locali libere. 
-  \item \macro{EAFNOSUPPORT} l'indirizzo non ha una famiglia di indirizzi
+  \item[\macro{EAGAIN}] non ci sono più porte locali libere. 
+  \item[\macro{EAFNOSUPPORT}] l'indirizzo non ha una famiglia di indirizzi
     corretta nel relativo campo.
-  \item \macro{EACCESS, EPERM} si è tentato di eseguire una connessione ad un
+  \item[\macro{EACCESS, EPERM}] si è tentato di eseguire una connessione ad un
     indirizzo broadcast senza che il socket fosse stato abilitato per il
     broadcast.
   \end{errlist}
   altri errori possibili sono: \macro{EFAULT}, \macro{EBADF},
-  \macro{ENOTSOCK}.
+  \macro{ENOTSOCK}, \macro{EISCONN} e \macro{EADDRINUSE}.}
 \end{prototype}
 
 La struttura dell'indirizzo deve essere inizializzata con l'indirizzo IP e il
@@ -828,16 +827,16 @@ man page 
   passiva e predispone una coda per le connessioni in arrivo di lunghezza pari
   a \var{backlog}. La funzione si può applicare solo a socket di tipo
   \macro{SOCK\_STREAM} o \macro{SOCK\_SEQPACKET}.
-
-  La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
-  codici di errore restituiti in \var{errno} sono i seguenti:
+  
+  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+    errore. I codici di errore restituiti in \var{errno} sono i seguenti:
   \begin{errlist}
-  \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+  \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
     valido.
-  \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
-  \item \macro{EOPNOTSUPP} il socket è di un tipo che non supporta questa
+  \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+  \item[\macro{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
     operazione.
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 
 
@@ -936,27 +935,27 @@ effettuare la comunicazione. Se non ci sono connessioni completate il processo
 viene messo in attesa. Il prototipo della funzione è il seguente:
 \begin{prototype}{sys/socket.h}
 {int accept(int sockfd, struct sockaddr *addr, socklen\_t *addrlen)} 
-  La funzione estrae la prima connessione relativa al socket \var{sockfd}
+  Estrae la prima connessione relativa al socket \var{sockfd}
   in attesa sulla coda delle connessioni complete, che associa ad nuovo socket
   con le stesse caratteristiche di \var{sockfd} (restituito dalla funzione
   stessa).  Il socket originale non viene toccato. Nella struttura
   \var{addr} e nella variabile \var{addrlen} vengono restituiti
   indirizzo e relativa lunghezza del client che si è connesso.
  
-  La funzione restituisce un numero di socket descriptor positivo in caso di
-  successo e -1 in caso di errore, nel qual caso la variabile \var{errno}
-  viene settata ai seguenti valori:
+  \bodydesc{La funzione restituisce un numero di socket descriptor positivo in
+    caso di successo e -1 in caso di errore, nel qual caso la variabile
+    \var{errno} viene settata ai seguenti valori:
 
   \begin{errlist}
-  \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+  \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
     valido.
-  \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
-  \item \macro{EOPNOTSUPP} il socket è di un tipo che non supporta questa
+  \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+  \item[\macro{EOPNOTSUPP}] il socket è di un tipo che non supporta questa
     operazione.    
-  \item \macro{EAGAIN} o \macro{EWOULDBLOCK} il socket è stato settato come
+  \item[\macro{EAGAIN} o \macro{EWOULDBLOCK}] il socket è stato settato come
     non bloccante, e non ci sono connessioni in attesa di essere accettate.
-  \item \macro{EPERM} Le regole del firewall non consentono la connessione.
-  \item \macro{ENOBUFS, ENOMEM} .  Questo spesso significa che l'allocazione
+  \item[\macro{EPERM}] Le regole del firewall non consentono la connessione.
+  \item[\macro{ENOBUFS, ENOMEM}] questo spesso significa che l'allocazione
     della memoria è limitata dai limiti sui buffer dei socket, non dalla
     memoria di sistema.
   \end{errlist}
@@ -964,7 +963,7 @@ viene messo in attesa. Il prototipo della funzione 
   socket come: \macro{EMFILE}, \macro{EINVAL}, \macro{ENOSR}, \macro{ENOBUFS},
   \macro{EFAULT}, \macro{EPERM}, \macro{ECONNABORTED},
   \macro{ESOCKTNOSUPPORT}, \macro{EPROTONOSUPPORT}, \macro{ETIMEDOUT},
-  \macro{ERESTARTSYS}.
+  \macro{ERESTARTSYS}.}
 \end{prototype}
 
 La funzione può essere usata solo con socket che supportino la connessione
@@ -1185,19 +1184,21 @@ certo socket; la prima restituisce l'indirizzo locale, la seconda quello
 remoto. 
 
 \begin{prototype}{sys/socket.h}
-{int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+  {int getsockname(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+  Legge l'indirizzo locale del socket \param{sockfd} nella struttura
+  \param{name}.
 
-  La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
-  codici di errore restituiti in \var{errno} sono i seguenti:
+\bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+  errore. I codici di errore restituiti in \var{errno} sono i seguenti:
   \begin{errlist}
-  \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+  \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
     valido.
-  \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
-  \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
+  \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+  \item[\macro{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
     eseguire l'operazione.
-  \item \macro{EFAULT} l'argomento \var{name} punta al di fuori dello
+  \item[\macro{EFAULT}] l'argomento \var{name} punta al di fuori dello
     spazio di indirizzi del processo.
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 
 La funzione \func{getsockname} si usa tutte le volte che si vuole avere
@@ -1213,20 +1214,22 @@ chiamata dopo il completamento di una connessione sul socket restituito da
 quella connessione.
 
 \begin{prototype}{sys/socket.h}
-{int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
-
-  La funzione restituisce 0 in caso di successo e -1 in caso di errore. I
-  codici di errore restituiti in \var{errno} sono i seguenti:
+  {int getpeername(int sockfd, struct sockaddr * name, socklen\_t * namelen)}
+  Legge l'indirizzo remoto del socket \param{sockfd} nella struttura
+  \param{name}.
+  
+  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+    errore. I codici di errore restituiti in \var{errno} sono i seguenti:
   \begin{errlist}
-  \item \macro{EBADF} l'argomento \var{sockfd} non è un file descriptor
+  \item[\macro{EBADF}] l'argomento \var{sockfd} non è un file descriptor
     valido.
-  \item \macro{ENOTSOCK} l'argomento \var{sockfd} non è un socket.
-  \item \macro{ENOTCONN} il socket non è connesso.
-  \item \macro{ENOBUFS} non ci sono risorse sufficienti nel sistema per
+  \item[\macro{ENOTSOCK}] l'argomento \var{sockfd} non è un socket.
+  \item[\macro{ENOTCONN}] il socket non è connesso.
+  \item[\macro{ENOBUFS}] non ci sono risorse sufficienti nel sistema per
     eseguire l'operazione.
-  \item \macro{EFAULT} l'argomento \var{name} punta al di fuori dello
+  \item[\macro{EFAULT}] l'argomento \var{name} punta al di fuori dello
     spazio di indirizzi del processo.
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 
 
index 46c502b..00ea801 100644 (file)
@@ -1396,14 +1396,14 @@ la funzione \func{access}, il cui prototipo 
 \begin{prototype}{unistd.h}
 {int access(const char *pathname, int mode)}
 
-  La funzione verifica i permessi di accesso, indicati da \var{mode}, per il
-  file indicato da \var{pathname}. 
+Verifica i permessi di accesso, indicati da \var{mode}, per il file indicato
+da \var{pathname}.
   
-  La funzione ritorna 0 se l'accesso è consentito, -1 altrimenti; in
-  quest'ultimo caso la variabile \var{errno} viene settata secondo i codici
-  di errore: \macro{EACCES}, \macro{EROFS}, \macro{EFAULT}, \macro{EINVAL},
+\bodydesc{La funzione ritorna 0 se l'accesso è consentito, -1 altrimenti; in
+  quest'ultimo caso la variabile \var{errno} viene settata secondo i codici di
+  errore: \macro{EACCES}, \macro{EROFS}, \macro{EFAULT}, \macro{EINVAL},
   \macro{ENAMETOOLONG}, \macro{ENOENT}, \macro{ENOTDIR}, \macro{ELOOP},
-  \macro{EIO}.
+  \macro{EIO}.}
 \end{prototype}
 
 I valori possibili per il parametro \var{mode} sono esprimibili come
@@ -1554,8 +1554,8 @@ funzione \func{umask}, il cui prototipo 
   Setta la maschera dei permessi dei bit al valore specificato da \var{mask}
   (di cui vengono presi solo i 9 bit meno significativi).
   
-  La funzione ritorna il precedente valore della maschera. È una delle poche
-  funzioni che non restituisce codici di errore.
+  \bodydesc{La funzione ritorna il precedente valore della maschera. È una
+    delle poche funzioni che non restituisce codici di errore.}
 \end{prototype}
 
 Questa maschera è una caratteristica di ogni processo e viene utilizzata per
@@ -1578,6 +1578,7 @@ login a $022$, e di norma gli utenti non hanno motivi per modificarlo. Se per
 si vuole che un processo possa creare un file che chiunque possa leggere
 allora occorrerà cambiare il valore di \func{umask}.
 
+
 \subsection{Le funzioni \func{chown}, \func{fchown} e \func{lchown}}
 \label{sec:file_chown}
 
index de338fe..9094ab3 100644 (file)
@@ -342,10 +342,11 @@ Uno stream viene chiuso con la funzione \func{fclose} il cui prototipo 
 \begin{prototype}{stdio.h}{int fclose(FILE * stream)}
   Chiude lo stream \param{stream}. 
   
-  Restituisce 0 in caso di successo e \macro{EOF} in caso di errore, nel qual
-  caso setta \var{errno} a \macro{EBADF} se il file descriptor indicato da
-  \param{stream} non è valido, o uno dei valori specificati dalla sottostante
-  funzione che è fallita (\func{close}, \func{write} o \func{fflush}).
+  \bodydesc{Restituisce 0 in caso di successo e \macro{EOF} in caso di errore,
+    nel qual caso setta \var{errno} a \macro{EBADF} se il file descriptor
+    indicato da \param{stream} non è valido, o uno dei valori specificati
+    dalla sottostante funzione che è fallita (\func{close}, \func{write} o
+    \func{fflush}).}
 \end{prototype}
 
 La funzione effettua uno scarico di tutti i dati presenti nei buffer di
@@ -361,7 +362,7 @@ prototipo 
 \begin{prototype}{stdio.h}{int fcloseall(void)}
   Chiude tutti gli stream. 
   
-  Restituisce 0 se non ci sono errori ed \macro{EOF} altrimenti.
+  \bodydesc{Restituisce 0 se non ci sono errori ed \macro{EOF} altrimenti.}
 \end{prototype}
 la funzione esegue lo scarico dei dati bufferizzati in uscita e scarta quelli
 in ingresso, chiudendo tutti i file. Questa funzione è provvista solo per i
@@ -458,13 +459,12 @@ formattati. Le due funzioni che si usano per l'I/O binario sono:
   \funcdecl{size\_t fwrite(const void * ptr, size\_t size, size\_t
     nmemb, FILE * stream)}
   
-  Le funzioni rispettivamente leggono e scrivono \param{nmemb} elementi
-  di dimensione \param{size} dal buffer \param{ptr} al file
-  \param{stream}.
+  Rispettivamente leggono e scrivono \param{nmemb} elementi di dimensione
+  \param{size} dal buffer \param{ptr} al file \param{stream}.
   
-  Entrambe le funzioni ritornano il numero di elementi letti o scritti,
-  in caso di errore o fine del file viene restituito un numero di
-  elementi inferiore al richiesto.
+  \bodydesc{Entrambe le funzioni ritornano il numero di elementi letti o
+    scritti, in caso di errore o fine del file viene restituito un numero di
+    elementi inferiore al richiesto.}
 \end{functions}
 
 In genere si usano queste funzioni quando si devono trasferire su file
@@ -558,8 +558,8 @@ gestione delle applicazioni multi-thread (si veda
   \funcdecl{size\_t fwrite\_unlocked(const void * ptr, size\_t size,
     size\_t nmemb, FILE * stream)}
   
-  Le funzioni sono identiche alle analoghe \func{fread} e \func{fwrite}
-  ma non acquisiscono il lock implicito sullo stream.
+  \bodydesc{Le funzioni sono identiche alle analoghe \func{fread} e
+    \func{fwrite} ma non acquisiscono il lock implicito sullo stream.}
 \end{functions}
 \noindent entrambe le funzioni sono estensioni GNU previste solo dalle
 \acr{glibc}.
@@ -581,7 +581,7 @@ rispettivi prototipi sono:
   \funcdecl{int fgetc(FILE *stream)} Legge un byte da \param{stream} e lo
   restituisce come intero. È una sempre una funzione.
   
-  \funcdecl{int getchar(void)} è equivalente a \func{getc(stdin)}.
+  \funcdecl{int getchar(void)} Equivalente a \func{getc(stdin)}.
   
   \bodydesc{Tutte queste funzioni leggono un byte alla volta, che viene
     restituito come intero; in caso di errore o fine del file il valore
@@ -621,7 +621,7 @@ byte restituiscono un carattere in formato esteso (cio
   \funcdecl{wint\_t fgetwc(FILE *stream)} Legge un carattere esteso da
   \param{stream} È una sempre una funzione.
   
-  \funcdecl{wint\_t getwchar(void)} è equivalente a \func{getwc(stdin)}.
+  \funcdecl{wint\_t getwchar(void)} Equivalente a \func{getwc(stdin)}.
   
   \bodydesc{Tutte queste funzioni leggono un carattere alla volta, in
     caso di errore o fine del file il valore di ritorno è \macro{WEOF}.}
@@ -639,7 +639,7 @@ precedenti usate per leggere: \func{putc}, \func{fputc} e
   \funcdecl{int fputc(FILE *stream)} Scrive il carattere \param{c} su
   \param{stream}. È una sempre una funzione.
   
-  \funcdecl{int putchar(void)} è equivalente a \func{putc(stdin)}.
+  \funcdecl{int putchar(void)} Equivalente a \func{putc(stdin)}.
   
   \bodydesc{Le funzioni scrivono sempre un carattere alla volta, il cui
     valore viene restituito in caso di successo; in caso di errore o
index 1fe5a7e..10630c5 100644 (file)
@@ -177,30 +177,30 @@ prototipo 
   \var{flags}, e, nel caso il file sia creato, con gli eventuali permessi
   specificati da \var{mode}.
   
-  La funzione ritorna il file descriptor in caso di successo e -1 in caso di
-  errore. In questo caso la variabile \var{errno} viene settata ad uno dei
-  valori:
+  \bodydesc{La funzione ritorna il file descriptor in caso di successo e -1 in
+    caso di errore. In questo caso la variabile \var{errno} viene settata ad
+    uno dei valori:
   \begin{errlist}
-  \item \macro{EEXIST} \var{pathname} esiste e si è specificato
+  \item[\macro{EEXIST}] \var{pathname} esiste e si è specificato
     \macro{O\_CREAT} e \macro{O\_EXCL}.  
-  \item \macro{EISDIR} \var{pathname} indica una directory e si è tentato
+  \item[\macro{EISDIR}] \var{pathname} indica una directory e si è tentato
     l'accesso in scrittura. 
-  \item \macro{ENOTDIR} si è specificato \macro{O\_DIRECTORY} e \var{pathname}
+  \item[\macro{ENOTDIR}] si è specificato \macro{O\_DIRECTORY} e \var{pathname}
     non è una directory.
-  \item \macro{ENXIO} si sono settati \macro{O\_NOBLOCK} o \macro{O\_WRONLY}
+  \item[\macro{ENXIO}] si sono settati \macro{O\_NOBLOCK} o \macro{O\_WRONLY}
     ed il file è una fifo che non viene letta da nessun processo o
     \var{pathname} è un file di dispositivo ma il dispositivo è assente.
-  \item \macro{ENODEV} \var{pathname} si riferisce a un file di dispositivo
+  \item[\macro{ENODEV}] \var{pathname} si riferisce a un file di dispositivo
     che non esiste.  
-  \item \macro{ETXTBSY} si è cercato di accedere in scrittura all'immagine di
+  \item[\macro{ETXTBSY}] si è cercato di accedere in scrittura all'immagine di
     un programma in esecuzione.
-  \item \macro{ELOOP} si sono incontrati troppi link simbolici nel risolvere
+  \item[\macro{ELOOP}] si sono incontrati troppi link simbolici nel risolvere
     pathname o si è indicato \macro{O\_NOFOLLOW} e \var{pathname} è un link
     simbolico.
   \end{errlist}
   ed inoltre \macro{EACCES}, \macro{ENAMETOOLONG}, \macro{ENOENT},
   \macro{EROFS}, \macro{EFAULT}, \macro{ENOSPC}, \macro{ENOMEM},
-  \macro{EMFILE} e \macro{ENFILE}.
+  \macro{EMFILE} e \macro{ENFILE}.}
 \end{functions}
 
 La funzione apre il file, usando il primo file descriptor libero, e crea
@@ -378,13 +378,13 @@ descriptor ritorna disponibile; il suo prototipo 
 \begin{prototype}{unistd.h}{int close(int fd)}
   Chiude il descrittore \var{fd}. 
   
-  La funzione ritorna 0 in caso di successo e -1 n caso di errore. In questo
-  caso \var{errno} è settata ai valori:
+  \bodydesc{La funzione ritorna 0 in caso di successo e -1 n caso di errore.
+    In questo caso \var{errno} è settata ai valori:
   \begin{errlist}
-    \item \macro{EBADF}  \var{fd} non è un descrittore valido.
-    \item \macro{EINTR} la funzione è stata interrotta da un segnale.
+    \item[\macro{EBADF}]  \var{fd} non è un descrittore valido.
+    \item[\macro{EINTR}] la funzione è stata interrotta da un segnale.
   \end{errlist}
-  ed inoltre \macro{EIO}.
+  ed inoltre \macro{EIO}.}
 \end{prototype}
 
 La chiusura di un file rilascia ogni blocco (il \textit{file locking} è
@@ -431,15 +431,16 @@ un valore qualsiasi con la funzione \func{lseek}, il cui prototipo 
   \headdecl{sys/types.h}
   \headdecl{unistd.h}
   \funcdecl{off\_t lseek(int fd, off\_t offset, int whence)}
-  La funzione setta la posizione attuale nel file. 
-
-  La funzione ritorna valore della posizione corrente in caso di successo e -1
-  in caso di errore nel qual caso \var{errno} viene settata ad uno dei valori:
+  Setta la posizione attuale nel file. 
+  
+  \bodydesc{La funzione ritorna valore della posizione corrente in caso di
+    successo e -1 in caso di errore nel qual caso \var{errno} viene settata ad
+    uno dei valori:
   \begin{errlist}
-    \item \macro{ESPIPE} \var{fd} è una pipe, un socket o una fifo.
-    \item \macro{EINVAL} \var{whence} non è un valore valido.
+    \item[\macro{ESPIPE}] \var{fd} è una pipe, un socket o una fifo.
+    \item[\macro{EINVAL}] \var{whence} non è un valore valido.
   \end{errlist}
-  ed inoltre \macro{EBADF}.
+  ed inoltre \macro{EBADF}.}
 \end{functions}
 
 La nuova posizione è settata usando il valore specificato da \var{offset},
@@ -491,52 +492,55 @@ Una volta che un file 
 utilizzando la funzione \func{read}, il cui prototipo è:
 \begin{prototype}{unistd.h}{ssize\_t read(int fd, void * buf, size\_t count)}
   
-  La funzione cerca di leggere \var{count} byte dal file \var{fd} al buffer
-  \var{buf}.
+  Cerca di leggere \var{count} byte dal file \var{fd} al buffer \var{buf}.
   
-  La funzione ritorna il numero di byte letti in caso di successo e -1 in
-  caso di errore, nel qual caso \var{errno} viene settata ad uno dei valori:
+  \bodydesc{La funzione ritorna il numero di byte letti in caso di successo e
+    -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+    valori:
   \begin{errlist}
-  \item \macro{EINTR} la funzione è stata interrotta da un segnale prima di
+  \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
     aver potuto leggere qualsiasi dato.
-    \item \macro{EAGAIN} la funzione non aveva nessun dato da restituire e si
-      era aperto il file in modalità \macro{O\_NONBLOCK}.
+  \item[\macro{EAGAIN}] la funzione non aveva nessun dato da restituire e si
+    era aperto il file in modalità \macro{O\_NONBLOCK}.
   \end{errlist}
   ed inoltre \macro{EBADF}, \macro{EIO}, \macro{EISDIR}, \macro{EBADF},
   \macro{EINVAL} e \macro{EFAULT} ed eventuali altri errori dipendenti dalla
-  natura dell'oggetto connesso a \var{fd}.
+  natura dell'oggetto connesso a \var{fd}.}
 \end{prototype}
 
 La funzione tenta di leggere \var{count} byte a partire dalla posizione
-corrente nel file; dopo la lettura la posizione è spostata automaticamente in
-avanti del numero di byte letti. Se \var{count} è zero la funzione
-restituisce zero senza nessun altro risultato.
+corrente nel file. Dopo la lettura la posizione sul file è spostata
+automaticamente in avanti del numero di byte letti. Se \var{count} è zero la
+funzione restituisce zero senza nessun altro risultato.
 
 Si deve sempre tener presente che non è detto che la funzione \func{read}
-restituisca il numero di byte richiesto, ci sono infatti varie ragioni per cui
-la funzione può restituire un numero di byte inferiore. Questo è un
-comportamento normale e non un errore, che però bisogna sempre tenere
-presente.
+restituisca sempre il numero di byte richiesto, ci sono infatti varie ragioni
+per cui la funzione può restituire un numero di byte inferiore; questo è un
+comportamento normale, e non un errore, che bisogna sempre tenere presente.
 
 La prima e più ovvia di queste ragioni è che si è chiesto di leggere più byte
 di quanto il file ne contenga. In questo caso il file viene letto fino alla
 sua fine, e la funzione ritorna regolarmente il numero di byte letti
-effettivamente. Se ripetessimo la lettura \func{read} restituirebbe uno zero.
-La condizione raggiungimento della fine del file non è un errore, e viene
-segnalata appunto da un valore di ritorno di \func{read} nullo, ripetere la
+effettivamente. 
+
+Raggiunta la fine del file, alla ripetizione di un'operazione di lettura,
+otterremmo il ritorno immediato di \func{read} con uno zero.  La condizione
+raggiungimento della fine del file non è un errore, e viene segnalata appunto
+da un valore di ritorno di \func{read} nullo. Ripetere ulteriormente la
 lettura non avrebbe nessun effetto se non quello di continuare a ricevere zero
 come valore di ritorno.
 
 Con i \textsl{file regolari} questa è l'unica situazione in cui si può avere
-un numero di byte letti inferiore a quello richiesto, ma la situazione è
-invece normale quando si legge da un terminale, o su una pipe. In tal caso
+un numero di byte letti inferiore a quello richiesto, ma questo non è vero
+quando si legge da un terminale, da una fifo o da una pipe. In tal caso
 infatti, se non ci sono dati in ingresso, la \func{read} si blocca e ritorna
 solo quando ne arrivano; se il numero di byte richiesti eccede quelli
-disponibili la funzione ritorna comunque, ma con un numero di byte inferiore.
+disponibili la funzione ritorna comunque, ma con un numero di byte inferiore a
+quelli richiesti.
 
 Lo stesso comportamento avviene caso di lettura dalla rete (cioè su un socket,
-come vedremo in \secref{sec:sock_io_behav}), o per certi dispositivi come le
-unità a nastro che restituiscono un singolo blocco di dati alla volta.
+come vedremo in \secref{sec:sock_io_behav}), o per certi dispositivi, come le
+unità a nastro, che restituiscono un singolo blocco di dati alla volta.
 
 In realtà anche le due condizioni segnalate dagli errori \func{EINTR} e
 \func{EAGAIN} non sono errori. La prima si verifica quando la \func{read} è
@@ -548,15 +552,18 @@ La seconda si verifica quando il file 
 sono dati in ingresso: la funzione allora ritorna immediatamente con un errore
 \macro{EAGAIN}\footnote{sotto BSD questo per questo errore viene usata la
   costante \macro{EWOULDBLOCK}, in GNU/Linux questa è sinonima di
-  \macro{EAGAIN}.} indicando che occorrerà provare a ripetere la lettura.
+  \macro{EAGAIN}.} che nel caso indica soltanto che occorrerà provare a
+ripetere la lettura.
 
 
-Lo standard Unix98\footnote{questa funzione, e l'analoga \func{pwrite} sono
+Nella seconda versione delle \textit{Single Unix
+  Specification}\footnote{questa funzione, e l'analoga \func{pwrite} sono
   state aggiunte nel kernel 2.1.60, il supporto nelle \acr{glibc}, compresa
   l'emulazione per i vecchi kernel che non hanno la system call, è stato
-  aggiunto con la versione 2.1} (vedi \secref{sec:intro_opengroup}) prevede la
-definizione di un'altra funzione di lettura, \func{pread}, che diventa
-accessibile con la definizione:
+  aggiunto con la versione 2.1} (quello che viene chiamato normalmente Unix98,
+vedi \secref{sec:intro_opengroup}) è stata introdotta la definizione di
+un'altra funzione di lettura, \func{pread}, che diventa accessibile con la
+definizione:
 \begin{verbatim}
        #define _XOPEN_SOURCE 500
 \end{verbatim}
@@ -564,20 +571,20 @@ il prototipo di questa funzione 
 \begin{prototype}{unistd.h}
 {ssize\_t pread(int fd, void * buf, size\_t count, off\_t offset)}
   
-La funzione cerca di leggere \var{count} byte dal file \var{fd}, a partire
-dalla posizione \var{offset}, nel buffer \var{buf}.
+Cerca di leggere \var{count} byte dal file \var{fd}, a partire dalla posizione
+\var{offset}, nel buffer \var{buf}.
   
-La funzione ritorna il numero di byte letti in caso di successo e -1 in caso
-di errore, nel qual caso \var{errno} viene settata secondo i valori già visti
-per \func{read} e \func{lseek}.
+\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e -1
+  in caso di errore, nel qual caso \var{errno} viene settata secondo i valori
+  già visti per \func{read} e \func{lseek}.}
 \end{prototype}
 
 Questa funzione serve quando si vogliono leggere dati dal file senza
-modificarne la posizione corrente. È sostanzialmente equivalente alla
-esecuzione di una \func{read} e una \func{lseek}, ma dato che la posizione sul
-file può essere condivisa fra vari processi (vedi \secref{sec:file_sharing}),
-essa permette di eseguire l'operazione atomicamente. Il valore di \var{offset}
-fa sempre riferimento all'inizio del file.
+modificarne la posizione corrente. È equivalente alla esecuzione di una
+\func{read} e una \func{lseek}, ma permette di eseguire l'operazione
+atomicamente. Questo può essere importante quando la posizione sul file viene
+condivisa da processi diversi (vedi \secref{sec:file_sharing}).  Il valore di
+\var{offset} fa sempre riferimento all'inizio del file.
 
 
 \subsection{La funzione \func{write}}
@@ -587,28 +594,29 @@ Una volta che un file 
 funzione \func{write}, il cui prototipo è:
 \begin{prototype}{unistd.h}{ssize\_t write(int fd, void * buf, size\_t count)}
   
-  La funzione scrive \var{count} byte dal buffer \var{buf} sul file \var{fd}.
+  Scrive \var{count} byte dal buffer \var{buf} sul file \var{fd}.
   
-  La funzione ritorna il numero di byte scritti in caso di successo e -1 in
-  caso di errore, nel qual caso \var{errno} viene settata ad uno dei valori:
+  \bodydesc{La funzione ritorna il numero di byte scritti in caso di successo
+    e -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+    valori:
   \begin{errlist}
-  \item \macro{EINVAL} \var{fd} è connesso ad un oggetto che non consente la
+  \item[\macro{EINVAL}] \var{fd} è connesso ad un oggetto che non consente la
     scrittura.
-  \item \macro{EFBIG} si è cercato di scrivere oltre la dimensione massima
+  \item[\macro{EFBIG}] si è cercato di scrivere oltre la dimensione massima
     consentita dal filesystem o il limite per le dimensioni dei file del
     processo o su una posizione oltre il massimo consentito.
-  \item \macro{EPIPE} \var{fd} è connesso ad una pipe il cui altro capo è
+  \item[\macro{EPIPE}] \var{fd} è connesso ad una pipe il cui altro capo è
     chiuso in lettura; in questo caso viene anche generato il segnale
     \macro{SIGPIPE}, se questo viene gestito (o bloccato o ignorato) la
     funzione ritorna questo errore.
-  \item \macro{EINTR} la funzione è stata interrotta da un segnale prima di
+  \item[\macro{EINTR}] la funzione è stata interrotta da un segnale prima di
     aver potuto scrivere qualsiasi dato.
-  \item \macro{EAGAIN} la funzione non aveva nessun dato da restituire e si
+  \item[\macro{EAGAIN}] la funzione non aveva nessun dato da restituire e si
     era aperto il file in modalità \macro{O\_NONBLOCK}.
   \end{errlist}
   ed inoltre \macro{EBADF}, \macro{EIO}, \macro{EISDIR}, \macro{EBADF},
   \macro{ENOSPC}, \macro{EINVAL} e \macro{EFAULT} ed eventuali altri errori
-  dipendenti dalla natura dell'oggetto connesso a \var{fd}.
+  dipendenti dalla natura dell'oggetto connesso a \var{fd}.}
 \end{prototype}
 
 Come nel caso di \func{read} la funzione tenta di scrivere \var{count} byte a
@@ -625,20 +633,20 @@ i file ordinari il numero di byte scritti 
 da \var{count}, a meno di un errore. Negli altri casi si ha lo stesso
 comportamento di \func{read}.
 
-Anche per \func{write} lo standard Unix98 definisce una analoga per scrivere
-alla posizione indicata senza modificare la posizione corrente nel file, il
-suo prototipo è:
+Anche per \func{write} lo standard Unix98 definisce una analoga \func{pwrite}
+per scrivere alla posizione indicata senza modificare la posizione corrente
+nel file, il suo prototipo è:
 \begin{prototype}{unistd.h}
 {ssize\_t pwrite(int fd, void * buf, size\_t count, off\_t offset)}
   
-La funzione cerca di scrivere sul file \var{fd}, a partire dalla posizione
-\var{offset}, \var{count} byte dal buffer \var{buf}.
+Cerca di scrivere sul file \var{fd}, a partire dalla posizione \var{offset},
+\var{count} byte dal buffer \var{buf}.
   
-La funzione ritorna il numero di byte letti in caso di successo e -1 in caso
-di errore, nel qual caso \var{errno} viene settata secondo i valori già visti
-per \func{write} e \func{lseek}.
+\bodydesc{La funzione ritorna il numero di byte letti in caso di successo e -1
+  in caso di errore, nel qual caso \var{errno} viene settata secondo i valori
+  già visti per \func{write} e \func{lseek}.}
 \end{prototype}
-
+e per essa valgono le stesse considerazioni fatte per \func{pread}.
 
 
 \section{Caratteristiche avanzate}
@@ -791,9 +799,9 @@ scarico dei dati dai buffer del kernel\footnote{come gi
 funzioni è \func{sync} il cui prototipo è:
 \begin{prototype}{unistd.h}{int sync(void)}
   
-  La funzione sincronizza buffer della cache dei file col disco.
+  Sincronizza il buffer della cache dei file col disco.
   
-  La funzione ritorna sempre zero.
+  \bodydesc{La funzione ritorna sempre zero.}
 \end{prototype}
 \noindent  i vari standard prevedono che la funzione si limiti a far partire
 le operazioni, ritornando immediatamente; in Linux (dal kernel 1.3.20) invece
@@ -817,13 +825,13 @@ usare le due funzioni \func{fsync} e \func{fdatasync}, i cui prototipi sono:
   \funcdecl{int fdatasync(int fd)}
   Sincronizza i dati del file \param{fd}.
   
-  La funzione ritorna 0 in caso di successo e -1 in caso di errore, nel qual
-  caso i codici restituiti in \var{errno} sono:
+  \bodydesc{La funzione ritorna 0 in caso di successo e -1 in caso di errore,
+    nel qual caso i codici restituiti in \var{errno} sono:
   \begin{errlist}
   \item[\macro{EINVAL}] \param{fd} è un file speciale che non supporta la
     sincronizzazione.
   \end{errlist}
-  ed inoltre \macro{EBADF}, \macro{EROFS} e \macro{EIO}.
+  ed inoltre \macro{EBADF}, \macro{EROFS} e \macro{EIO}.}
 \end{functions}
 
 Entrambe le funzioni forzano la sincronizzazione col disco di tutti i dati del
@@ -849,15 +857,16 @@ comportamento analogo all'interno di uno stesso processo \textit{duplicando}
 un file descriptor. Per far questo si usa la funzione \func{dup} il cui
 prototipo è:
 \begin{prototype}{unistd.h}{int dup(int oldfd)}
-  La funzione crea una copia del file descriptor \param{oldfd}.
+  Crea una copia del file descriptor \param{oldfd}.
   
-  La funzione ritorna il nuovo file descriptor in caso di successo e -1 in
-  caso di errore, nel qual caso \var{errno} viene settata ad uno dei valori:
+  \bodydesc{La funzione ritorna il nuovo file descriptor in caso di successo e
+    -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+    valori:
   \begin{errlist}
   \item[\macro{EBADF}] \param{oldfd} non è un file aperto.
   \item[\macro{EMFILE}] si è raggiunto il numero massimo consentito di file
     descriptor aperti.
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 
 La funzione ritorna, come \func{open}, il primo file descriptor libero. Il
@@ -888,16 +897,17 @@ Una diversa versione della funzione, \func{dup2} viene utilizzata per
 specificare esplicitamente il nuovo file descriptor; il suo prototipo è:
 \begin{prototype}{unistd.h}{int dup2(int oldfd, int newfd)}
   
-  La funzione rende \param{newfd} una copia del file descriptor \param{oldfd}.
+  Rende \param{newfd} una copia del file descriptor \param{oldfd}.
   
-  La funzione ritorna il nuovo file descriptor in caso di successo e -1 in
-  caso di errore, nel qual caso \var{errno} viene settata ad uno dei valori:
+  \bodydesc{La funzione ritorna il nuovo file descriptor in caso di successo e
+    -1 in caso di errore, nel qual caso \var{errno} viene settata ad uno dei
+    valori:
   \begin{errlist}
-  \item \macro{EBADF} \param{oldfd} non è un file aperto o \param{newfd} ha un
+  \item[\macro{EBADF}] \param{oldfd} non è un file aperto o \param{newfd} ha un
     valore fuori dall'intervallo consentito per i file descriptor.
-  \item \macro{EMFILE} si è raggiunto il numero massimo consentito di file
+  \item[\macro{EMFILE}] si è raggiunto il numero massimo consentito di file
     descriptor aperti.
-  \end{errlist}
+  \end{errlist}}
 \end{prototype}
 \noindent la funzione chiude il file descriptor \param{newfd} se è aperto.
 
@@ -932,15 +942,16 @@ file descriptor viene usata la funzione \func{fcntl} il cui prototipo 
   \funcdecl{int fcntl(int fd, int cmd)}
   \funcdecl{int fcntl(int fd, int cmd, long arg)}
   \funcdecl{int fcntl(int fd, int cmd, struct flock * lock)}
-  La funzione esegue una delle possibili operazioni specificate da \param{cmd}
+  Esegue una delle possibili operazioni specificate da \param{cmd}
   sul file \param{fd}.
   
-  La funzione ha valori di ritorno diversi a seconda dell'operazione. In caso
-  di errore il valore di ritorno è -1 e la variabile \var{errno} viene settata
-  ad un opportuno codice, quelli validi in generale sono:
+  \bodydesc{La funzione ha valori di ritorno diversi a seconda
+    dell'operazione. In caso di errore il valore di ritorno è -1 e la
+    variabile \var{errno} viene settata ad un opportuno codice, quelli validi
+    in generale sono:
   \begin{errlist}
-  \item \macro{EBADF} \param{oldfd} non è un file aperto.
-  \end{errlist}
+  \item[\macro{EBADF}] \param{oldfd} non è un file aperto.
+  \end{errlist}}
 \end{functions}
 
 Il comportamento di questa funzione è determinato dal valore del comando
@@ -1034,26 +1045,25 @@ per ogni singolo dispositivo.  Il prototipo di questa funzione 
 
 \begin{prototype}{sys/ioctl.h}{int ioctl(int fd, int request, ...)}
   
-  La funzione manipola il sottostante dispositivo, usando il parametro
-  \param{request} per specificare l'operazione richiesta e il terzo parametro
-  (che usualmente è di tipo \param{char * argp}) per passare o ricevere
-  l'informazione necessaria al dispositivo.
+  Manipola il dispositivo sottostante, usando il parametro \param{request} per
+  specificare l'operazione richiesta e il terzo parametro (usualmente di tipo
+  \param{char * argp}) per il trasferimento dell'informazione necessaria.
   
-  La funzione nella maggior parte dei casi ritorna 0, alcune operazioni usano
-  però il valore di ritorno per restituire informazioni. In caso di errore
-  viene sempre restituito -1 e \var{errno} viene settata ad uno dei valori
-  seguenti:
+  \bodydesc{La funzione nella maggior parte dei casi ritorna 0, alcune
+    operazioni usano però il valore di ritorno per restituire informazioni. In
+    caso di errore viene sempre restituito -1 e \var{errno} viene settata ad
+    uno dei valori seguenti:
   \begin{errlist}
-  \item \macro{ENOTTY} il file \param{fd} non è associato con un device.
-  \item \macro{EINVAL} gli argomenti \param{request} o \param{argp} non sono
+  \item[\macro{ENOTTY}] il file \param{fd} non è associato con un device.
+  \item[\macro{EINVAL}] gli argomenti \param{request} o \param{argp} non sono
     validi.
   \end{errlist}
-  ed inoltre \macro{EBADF} e \macro{EFAULT}.
+  ed inoltre \macro{EBADF} e \macro{EFAULT}.}
 \end{prototype}
 
 La funzione serve in sostanza per fare tutte quelle operazioni che non si
-adattano all'architettura di I/O di unix e che non è possibile effettuare con
-le funzioni esaminate finora. Per questo motivo non è possibile fare altro che
-una descrizione generica; torneremo ad esaminarla in seguito, quando si
-tratterà di applicarla ad alcune problematiche specifiche.
+adattano al design dell'architettura dei file e che non è possibile effettuare
+con le funzioni esaminate finora. Per questo motivo non è possibile fare altro
+che darne una descrizione generica; torneremo ad esaminarla in seguito, quando
+si tratterà di applicarla ad alcune problematiche specifiche.
 
index 180d9aa..8240d45 100644 (file)
@@ -595,8 +595,8 @@ Infine TCP definisce una \textit{maximum segment size} MSS che annuncia
 all'altro capo la dimensione massima del segmento di dati.
 
 
-\subsection{Il passaggio dei dati in TCP}
-\label{sec:net_tcp_pass}
+%\subsection{Il passaggio dei dati in TCP}
+%\label{sec:net_tcp_pass}
 
-\subsection{Il passaggio dei dati in UDP}
-\label{sec:net_udp_pass}
+%\subsection{Il passaggio dei dati in UDP}
+%\label{sec:net_udp_pass}
index 4278133..d7d22cc 100644 (file)
@@ -131,7 +131,7 @@ prototipo della funzione 
   Causa la conclusione ordinaria del programma restituendo il valore
   \var{status} al processo padre.
 
-  La funzione non ritorna. Il processo viene terminato
+  \bodydesc{La funzione non ritorna. Il processo viene terminato.}
 \end{prototype}
 
 La funzione \func{exit} è pensata per una conclusione pulita di un programma
@@ -150,7 +150,7 @@ prototipo della funzione 
   Causa la conclusione immediata del programma restituendo il valore
   \var{status} al processo padre.
 
-  La funzione non ritorna. Il processo viene terminato.
+  \bodydesc{La funzione non ritorna. Il processo viene terminato.}
 \end{prototype}
 
 La funzione chiude tutti i file descriptor appartenenti al processo (si tenga
@@ -182,11 +182,11 @@ certo numero funzioni che verranno eseguite all'uscita dal programma (sia per
 la chiamata ad \func{exit} che per il ritorno di \func{main}). La prima
 funzione che si può utilizzare a tal fine è:
 \begin{prototype}{stdlib.h}{void atexit(void (*function)(void))}
-  Registra la funzione \var{function} per essere chiamata all'uscita dal
+  Registra la funzione \param{function} per essere chiamata all'uscita dal
   programma. 
-
-  La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
-  \texttt{errno} non viene settata.
+  
+  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+    fallimento, \var{errno} non viene settata.}
 \end{prototype}
 
 La funzione richiede come argomento l'indirizzo della opportuna da chiamare
@@ -199,9 +199,9 @@ sistemi), il cui prototipo 
   Registra la funzione \var{function} per essere chiamata all'uscita dal
   programma. Tutte le funzioni registrate vengono chiamate in ordine inverso
   rispetto a quello di registrazione.
-
-  La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
-  \var{errno} non viene settata.
+  
+  \bodydesc{La funzione restituisce 0 in caso di successo e -1 in caso di
+    fallimento, \var{errno} non viene settata.}
 \end{prototype}
 
 In questo caso la funzione da chiamare prende due parametri, il primo dei
@@ -603,15 +603,16 @@ analoghe system call a cui fanno da interfaccia (ad esempio per implementare
 una propria versione di \func{malloc}. Le funzioni sono:
 \begin{functions}
   \headdecl{unistd.h}
-  \funcdecl{int *brk(void end\_data\_segment)}
+  \funcdecl{int brk(void * end\_data\_segment)}
   Sposta la fine del segmento dei dati all'indirizzo specificato da
   \var{end\_data\_segment}.
   
-  La funzione restituisce 0 in caso di successo e -1 in caso di fallimento,
-  nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
-  \funcdecl{int *sbrk(ptrdiff\_t increment)}
-  Incrementa lo spazio dati di un programma di \var{increment}. Un valore
-  zero restituisce l'attuale posizione della fine del segmento dati.
+  La funzione restituisce 0 in caso di successo e -1 in caso di
+    fallimento, nel qual caso \var{errno} viene settata a \macro{ENOMEM}.
+
+  \funcdecl{void * sbrk(ptrdiff\_t increment)} Incrementa lo spazio dati di un
+  programma di \var{increment}. Un valore zero restituisce l'attuale posizione
+  della fine del segmento dati.
   
   La funzione restituisce il puntatore all'inizio della nuova zona di memoria
   allocata in caso di successo e \macro{NULL} in caso di fallimento, nel qual
@@ -710,8 +711,6 @@ Le funzioni per bloccare e sbloccare singole sezioni di memoria sono
   sono mantenute in RAM per tutta la durata del blocco.
 
   \funcdecl{int munlock(const void *addr, size\_t len)}
-  Alloca \var{size} byte nello heap. La memoria non viene inizializzata.
-
   Sblocca l'intervallo di memoria da \var{addr} per \var{len} byte.  
 
   
@@ -812,12 +811,12 @@ Per gestire le opzioni all'interno dei argomenti a linea di comando passati in
 che ha il seguente prototipo:
 \begin{prototype}{unistd.h}
 {int getopt(int argc, char * const argv[], const char * optstring)}
-La funzione esegue il parsing degli argomenti passati da linea di comando
+Esegue il parsing degli argomenti passati da linea di comando
 riconoscendo le possibili opzioni segnalate con \var{optstring}.
 
-Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un parametro
-all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non esistono altre
-opzioni.
+\bodydesc{Ritorna il carattere che segue l'opzione, \cmd{':'} se manca un
+  parametro all'opzione, \cmd{'?'} se l'opzione è sconosciuta, e -1 se non
+  esistono altre opzioni.}
 \end{prototype}
 
 Questa funzione prende come argomenti le due variabili \var{argc} e \var{argv}
@@ -1019,8 +1018,9 @@ valori delle variabili di ambiente, il suo prototipo 
   Esamina l'ambiente del processo cercando una stringa che corrisponda a
   quella specificata da \param{name}. 
   
-  La funzione \macro{NULL} se non trova nulla, o il puntatore alla stringa che
-  corrisponde (di solito nella forma \texttt{NOME=valore}).
+  \bodydesc{La funzione ritorna \macro{NULL} se non trova nulla, o il
+    puntatore alla stringa che corrisponde (di solito nella forma
+    \texttt{NOME=valore}).}
 \end{prototype}
 
 Oltre a questa funzione di lettura, che è l'unica definita dallo standard ANSI
@@ -1052,22 +1052,27 @@ previste nei vari standard unix e disponibili in Linux 
   \label{tab:proc_env_func}
 \end{table}
 
-In Linux solo le prime quattro funzioni di \curtab\ sono definite; i prototipi
-delle restanti tre sono i seguenti:
-
+In Linux solo le prime quattro funzioni di \curtab\ sono definite; delle tre
+restanti le prime due, \func{putenv} e \func{setenv} servono per assegnare
+nuove variabili di ambiente, i loro prototipi sono i seguenti:
 \begin{functions}
-  \headdecl{stdlib.h}
-  \funcdecl{int putenv(char *string)}
-  La funzione aggiunge la stringa \param{string} all'ambiente.
+  \headdecl{stdlib.h} 
+  
+  \funcdecl{int putenv(char *string)} Aggiunge la stringa \param{string}
+  all'ambiente.
+  
   \funcdecl{int setenv(const char *name, const char *value, int overwrite)}
-  La funzione setta la variabile di ambiente \param{name} al valore
-  \param{value}.
+  Setta la variabile di ambiente \param{name} al valore \param{value}.
+  
+  \bodydesc{Entrambe le funzioni ritornano 0 in caso di successo e -1 per un
+    errore, che è sempre \macro{ENOMEM}.}
+\end{functions}
+\noindent la terza è:
+\begin{functions}
+  \headdecl{stdlib.h}
   
-  Entrambe le funzioni ritornano 0 in caso di successo e -1 per un errore, che
-  è sempre \macro{ENOMEM}.
-
   \funcdecl{void unsetenv(const char *name)}
-  La funzione rimuove la variabile di ambiente \param{name}.  
+  Rimuove la variabile di ambiente \param{name}.  
 \end{functions}
 
 Per cancellare una variabile di ambiente si usa \func{unsetenv}, che elimina
@@ -1191,21 +1196,32 @@ efficiente, quello dell'uscita in caso di errore.
 
 Il C però non consente di effettuare un salto ad una label definita in
 un'altra funzione, per cui se l'errore avviene in funzioni profondamente
-annidate occorre usare la funzioni \func{setjmp} e \func{longjmp}, il cui
-prototipo è:
+annidate occorre usare quello che viene chiamato un salto \textsl{non-locale};
+questo viene fatto usando salvando il contesto dello stack nel punto in cui si
+vuole tornare in caso di errore, e ripristinandolo quando l'occorrenza capita.
+
+
+La funzione che permette di salvare il contesto dello stack è \func{setjmp},
+il cui prototipo è:
 
 \begin{functions}
   \headdecl{setjmp.h}
   \funcdecl{void setjmp(jmp\_buf env)}
   
-  La funzione salva il contesto dello stack in \param{env} per un successivo
-  uso da parte di \func{longjmp}. Il contesto viene invalidato se la routine
-  che ha chiamato \func{setjmp} ritorna.
+  Salva il contesto dello stack in \param{env} per un successivo uso da parte
+  di \func{longjmp}. Il contesto viene invalidato se la routine che ha
+  chiamato \func{setjmp} ritorna.
   
-  La funzione ritorna zero quando è chiamata direttamente e un valore diverso
-  da zero quando ritorna da una chiamata di \func{longjmp} che usa il contesto
-  salvato in precedenza.
+  \bodydesc{La funzione ritorna zero quando è chiamata direttamente e un
+    valore diverso da zero quando ritorna da una chiamata di \func{longjmp}
+    che usa il contesto salvato in precedenza.}
+\end{functions}
+
 
+Per poter effettuare un salto non locale si usa la funzione \func{longjmp}; il
+suo prototipo è:
+\begin{functions}
+  \headdecl{setjmp.h}
   \funcdecl{void longjmp(jmp\_buf env, int val)}
   
   Ripristina il contesto dello stack salvato dall'ultima chiamata di
@@ -1213,6 +1229,6 @@ prototipo 
   di \func{setjmp} con un valore \param{val}. Il valore di \param{val} deve
   essere diverso da zero, se viene specificato 0 sarà usato 1 al suo posto.
 
-  La funzione non ritorna.
+  \bodydesc{La funzione non ritorna.}
 \end{functions}
 
index 685827a..8c8a671 100644 (file)
@@ -190,8 +190,8 @@ ottenuti da programma usando le funzioni:
 \begin{functions}
 \headdecl{sys/types.h}
 \headdecl{unistd.h}
-\funcdecl{pid\_t getpid(void)} restituisce il pid del processo corrente.
-\funcdecl{pid\_t getppid(void)} restituisce il pid del padre del processo
+\funcdecl{pid\_t getpid(void)} Restituisce il pid del processo corrente.
+\funcdecl{pid\_t getppid(void)} Restituisce il pid del padre del processo
     corrente.
 
 \bodydesc{Entrambe le funzioni non riportano condizioni di errore.}
@@ -234,16 +234,18 @@ prototipo della funzione 
   \headdecl{sys/types.h} 
   \headdecl{unistd.h} 
   \funcdecl{pid\_t fork(void)} 
-  Restituisce zero al padre e il \acr{pid} al figlio in caso di successo,
-  ritorna -1 al padre (senza creare il figlio) in caso di errore;
-  \texttt{errno} può assumere i valori:
+  Crea un nuovo processo.
+  
+  \bodydesc{Restituisce zero al padre e il \acr{pid} al figlio in caso di
+    successo, ritorna -1 al padre (senza creare il figlio) in caso di errore;
+    \var{errno} può assumere i valori:
   \begin{errlist}
   \item[\macro{EAGAIN}] non ci sono risorse sufficienti per creare un'altro
     processo (per allocare la tabella delle pagine e le strutture del task) o
     si è esaurito il numero di processi disponibili.
   \item[\macro{ENOMEM}] non è stato possibile allocare la memoria per le
     strutture necessarie al kernel per creare il nuovo processo.
-  \end{errlist}
+  \end{errlist}}
 \end{functions}
 
 Dopo il successo dell'esecuzione di una \func{fork} sia il processo padre che
@@ -782,7 +784,6 @@ prototipo 
 Sospende il processo corrente finché un figlio non è uscito, o finché un
 segnale termina il processo o chiama una funzione di gestione. 
 
-
 \bodydesc{
 La funzione restituisce il \acr{pid} del figlio in caso di successo e -1 in
 caso di errore; \var{errno} può assumere i valori:
@@ -818,16 +819,17 @@ questa funzione; il suo prototipo 
 \headdecl{sys/types.h}
 \headdecl{sys/wait.h}
 \funcdecl{pid\_t waitpid(pid\_t pid, int * status, int options)} 
+Attende la conclusione di un processo figlio.
 
-La funzione restituisce il \acr{pid} del processo che è uscito, 0 se è stata
-specificata l'opzione \macro{WNOHANG} e il processo non è uscito e -1 per un
-errore, nel qual caso \var{errno} assumerà i valori:
+\bodydesc{La funzione restituisce il \acr{pid} del processo che è uscito, 0 se
+  è stata specificata l'opzione \macro{WNOHANG} e il processo non è uscito e
+  -1 per un errore, nel qual caso \var{errno} assumerà i valori:
   \begin{errlist}
   \item[\macro{EINTR}] se non è stata specificata l'opzione \macro{WNOHANG} e
     la funzione è stata interrotta da un segnale.
   \item[\macro{ECHILD}] il processo specificato da \var{pid} non esiste o non è
     figlio del processo chiamante.
-  \end{errlist}
+  \end{errlist}}
 \end{functions}
 
 Le differenze principali fra le due funzioni sono che \func{wait} si blocca
@@ -960,7 +962,7 @@ accessibili definendo la costante \macro{\_USE\_BSD}, sono:
   \headdecl{sys/resource.h}
   \funcdecl{pid\_t wait4(pid\_t pid, int * status, int options, struct rusage
     * rusage)} 
-  La funzione è identica a \func{waitpid} sia per comportamento che per i
+  È identica a \func{waitpid} sia per comportamento che per i
   valori dei parametri, ma restituisce in \var{rusage} un sommario delle
   risorse usate dal processo (per i dettagli vedi \secref{sec:sys_xxx})
   \funcdecl{pid\_t wait3(int *status, int options, struct rusage *rusage)}
@@ -1347,16 +1349,16 @@ prototipi sono i seguenti:
 \begin{functions}
   \headdecl{unistd.h}
   \headdecl{sys/types.h}  
-  \funcdecl{uid\_t getuid(void)} restituisce il \textit{real user ID} del
+  \funcdecl{uid\_t getuid(void)} Restituisce il \textit{real user ID} del
   processo corrente.
 
-  \funcdecl{uid\_t geteuid(void)} restituisce l'\textit{effective user ID} del
+  \funcdecl{uid\_t geteuid(void)} Restituisce l'\textit{effective user ID} del
   processo corrente.
 
-  \funcdecl{gid\_t getgid(void)} restituisce il \textit{real group ID} del
+  \funcdecl{gid\_t getgid(void)} Restituisce il \textit{real group ID} del
   processo corrente.
 
-  \funcdecl{gid\_t getegid(void)} restituisce l'\textit{effective group ID} del
+  \funcdecl{gid\_t getegid(void)} Restituisce l'\textit{effective group ID} del
   processo corrente.
   
   \bodydesc{Queste funzioni non riportano condizioni di errore.}
@@ -1414,10 +1416,10 @@ seguono la semantica POSIX che prevede l'esistenza di \textit{saved user id} e
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setuid(uid\_t uid)} setta l'\textit{user ID} del processo
+\funcdecl{int setuid(uid\_t uid)} Setta l'\textit{user ID} del processo
 corrente.
 
-\funcdecl{int setgid(gid\_t gid)} setta il \textit{group ID} del processo
+\funcdecl{int setgid(gid\_t gid)} Setta il \textit{group ID} del processo
 corrente.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1513,11 +1515,11 @@ prototipi sono:
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} setta il \textit{real user
+\funcdecl{int setreuid(uid\_t ruid, uid\_t euid)} Setta il \textit{real user
   ID} e l'\textit{effective user ID} del processo corrente ai valori
 specificati da \var{ruid} e \var{euid}.
   
-\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} setta il \textit{real group
+\funcdecl{int setregid(gid\_t rgid, gid\_t egid)} Setta il \textit{real group
   ID} e l'\textit{effective group ID} del processo corrente ai valori
 specificati da \var{rgid} e \var{egid}.
 
@@ -1567,12 +1569,12 @@ e permettono un completo controllo su tutti gli identificatori (\textit{real},
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} setta il
+\funcdecl{int setresuid(uid\_t ruid, uid\_t euid, uid\_t suid)} Setta il
 \textit{real user ID}, l'\textit{effective user ID} e il \textit{saved user
   ID} del processo corrente ai valori specificati rispettivamente da
 \var{ruid}, \var{euid} e \var{suid}.
   
-\funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} setta il
+\funcdecl{int setresgid(gid\_t rgid, gid\_t egid, gid\_t sgid)} Setta il
 \textit{real group ID}, l'\textit{effective group ID} e il \textit{saved group
   ID} del processo corrente ai valori specificati rispettivamente da
 \var{rgid}, \var{egid} e \var{sgid}.
@@ -1599,10 +1601,10 @@ supportate dalla maggior parte degli unix) e usate per cambiare gli
 \headdecl{unistd.h}
 \headdecl{sys/types.h}
 
-\funcdecl{int seteuid(uid\_t uid)} setta l'\textit{effective user ID} del
+\funcdecl{int seteuid(uid\_t uid)} Setta l'\textit{effective user ID} del
 processo corrente a \var{uid}.
 
-\funcdecl{int setegid(gid\_t gid)} setta l'\textit{effective group ID} del
+\funcdecl{int setegid(gid\_t gid)} Setta l'\textit{effective group ID} del
 processo corrente a \var{gid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
@@ -1643,10 +1645,10 @@ usate se si intendono scrivere programmi portabili; i loro prototipi sono:
 \begin{functions}
 \headdecl{sys/fsuid.h}
 
-\funcdecl{int setfsuid(uid\_t fsuid)} setta il \textit{filesystem user ID} del
+\funcdecl{int setfsuid(uid\_t fsuid)} Setta il \textit{filesystem user ID} del
 processo corrente a \var{fsuid}.
 
-\funcdecl{int setfsgid(gid\_t fsgid)} setta l'\textit{filesystem group ID} del
+\funcdecl{int setfsgid(gid\_t fsgid)} Setta l'\textit{filesystem group ID} del
 processo corrente a \var{fsgid}.
 
 \bodydesc{Le funzioni restituiscono 0 in caso di successo e -1 in caso
index f67c571..072b1d1 100644 (file)
@@ -12,6 +12,8 @@ anche essere usati come forma elementare di comunicazione fra processi (ad
 esempio vengono usati per il controllo di sessione), per notificare eventi
 (come la terminazione di un processo figlio), etc.
 
+
+
 \section{I concetti base}
 \label{sec:sig_base}
 
@@ -705,8 +707,8 @@ comportamento, pur mantenendone immutato il prototipo\footnote{in realt
   Installa una nuova funzione di gestione (manipolatore) per il segnale
   \param{signum}, usando il manipolatore \param{handler}.
   
-  La funzione ritorna il precedente manipolatore in caso di successo o
-  \macro{SIG\_ERR} in caso di errore.
+  \bodydesc{La funzione ritorna il precedente manipolatore in caso di successo
+    o \macro{SIG\_ERR} in caso di errore.}
 \end{prototype}
 
 In questa definizione si è usato il tipo \type{sighandler\_t} che è una
index 0efc4fd..ec88664 100644 (file)
@@ -111,23 +111,25 @@ protocollo; in genere quest'ultimo 
 socket, per cui viene messo a zero (con l'eccezione dei \textit{raw socket}).
 
 \begin{prototype}{sys/socket.h}{int socket(int domain, int type, int protocol)}
+
+  Apre un socket.
   
-  La funzione restituisce un intero positivo se riesce, e -1 se fallisce, in
-  quest'ultimo caso la variabile \var{errno} è settata con i seguenti
-  codici di errore:
+  \bodydesc{La funzione restituisce un intero positivo se riesce, e -1 se
+    fallisce, in quest'ultimo caso la variabile \var{errno} è settata con i
+    seguenti codici di errore:
 
   \begin{errlist}
-  \item \macro{EPROTONOSUPPORT} Il tipo di socket o il protocollo scelto non
+  \item[\macro{EPROTONOSUPPORT}] Il tipo di socket o il protocollo scelto non
     sono supportati nel dominio.
-  \item \macro{ENFILE} Il kernel non ha memoria sufficiente a creare una
+  \item[\macro{ENFILE}] Il kernel non ha memoria sufficiente a creare una
     nuova struttura per il socket.
-  \item \macro{EMFILE} Si è ecceduta la tabella dei file.
-  \item \macro{EACCES} Non si hanno privilegi per creare un socket nel
+  \item[\macro{EMFILE}] Si è ecceduta la tabella dei file.
+  \item[\macro{EACCES}] Non si hanno privilegi per creare un socket nel
     dominio o con il protocollo specificato.
-  \item \macro{EINVAL} Protocollo sconosciuto o dominio non disponibile.
-  \item \macro{ENOBUFS} o \macro{ENOMEM} Non c'è sufficiente memoria per
-    creare il socket.
-  \end{errlist}
+  \item[\macro{EINVAL}] Protocollo sconosciuto o dominio non disponibile.
+  \item[\macro{ENOBUFS}] Non c'è sufficiente memoria per creare il socket (può
+    essere anche \macro{ENOMEM}).
+  \end{errlist}}
 \end{prototype}
 
 Si noti che la creazione del socket non comporta nulla riguardo
@@ -692,12 +694,12 @@ seguenti:
   \macro{INET6\_ADDRSTRLEN} per indirizzi IPv6; la lunghezza del buffer deve
   comunque venire specificata attraverso il parametro \var{len}.
  
-  La funzione restituisce un puntatore non nullo a \var{dest} in caso di
-  successo e un puntatore nullo in caso di fallimento, in quest'ultimo caso
-  viene settata la variabile \var{errno} con il valore \macro{ENOSPC} in
-  caso le dimensioni dell'indirizzo eccedano la lunghezza specificata da
-  \var{len} o \macro{ENOAFSUPPORT} in caso \var{af} non sia una famiglia di
-  indirizzi valida.
+  \bodydesc{La funzione restituisce un puntatore non nullo a \var{dest} in
+    caso di successo e un puntatore nullo in caso di fallimento, in
+    quest'ultimo caso viene settata la variabile \var{errno} con il valore
+    \macro{ENOSPC} in caso le dimensioni dell'indirizzo eccedano la lunghezza
+    specificata da \var{len} o \macro{ENOAFSUPPORT} in caso \var{af} non sia
+    una famiglia di indirizzi valida.}
 \end{prototype}
 
 Gli indirizzi vengono convertiti da/alle rispettive strutture di indirizzo
index bd5822b..6410f1a 100644 (file)
@@ -149,8 +149,8 @@ riportare in opportuni messaggi le condizioni di errore verificatesi.  La
 prima funzione che si può usare per ricavare i messaggi di errore è
 \func{strerror}, il cui prototipo è:
 \begin{prototype}{string.h}{char * strerror(int errnum)} 
-  La funzione ritorna una stringa (statica) che descrive l'errore il cui
-  codice è passato come parametro.
+  Ritorna una stringa (statica) che descrive l'errore il cui codice è passato
+  come parametro.
 \end{prototype}
 
 In generale \func{strerror} viene usata passando \var{errno} come parametro;
@@ -162,7 +162,7 @@ provvista\footnote{questa funzione 
   standard POSIX} una versione apposita:
 \begin{prototype}{string.h}
 {char * strerror\_r(int errnum, char * buff, size\_t size)} 
-  La funzione è analoga a \func{strerror} ma ritorna il messaggio in un buffer
+  Analoga a \func{strerror} ma ritorna il messaggio in un buffer
   specificato da \param{buff} di lunghezza massima (compreso il terminatore)
   \param{size}.
 \end{prototype}
@@ -178,8 +178,8 @@ Una seconda funzione usata per riportare i codici di errore in maniera
 automatizzata sullo standard error (vedi \secref{sec:file_std_descr}) è
 \func{perror}, il cui prototipo è:
 \begin{prototype}{stdio.h}{void perror (const char *message)} 
-  La funzione stampa il messaggio di errore relativo al valore corrente di
-  \var{errno} sullo standard error; preceduto dalla stringa \var{message}.
+  Stampa il messaggio di errore relativo al valore corrente di \var{errno}
+  sullo standard error; preceduto dalla stringa \var{message}.
 \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