From 0c7fb286c2c1b480ed81f7ce8d506b179e5d291e Mon Sep 17 00:00:00 2001 From: Simone Piccardi Date: Thu, 13 Dec 2001 18:24:15 +0000 Subject: [PATCH] Risistemati i prototipi delle funzioni, adesso dovrebbero essere un po' piu` leggibili. --- elemtcp.tex | 127 ++++++++++++++------------- filedir.tex | 17 ++-- filestd.tex | 32 +++---- fileunix.tex | 240 +++++++++++++++++++++++++++------------------------ network.tex | 8 +- process.tex | 104 ++++++++++++---------- prochand.tex | 54 ++++++------ signal.tex | 6 +- socket.tex | 36 ++++---- system.tex | 10 +-- 10 files changed, 335 insertions(+), 299 deletions(-) diff --git a/elemtcp.tex b/elemtcp.tex index effafc3..f092de0 100644 --- a/elemtcp.tex +++ b/elemtcp.tex @@ -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} diff --git a/filedir.tex b/filedir.tex index 46c502b..00ea801 100644 --- a/filedir.tex +++ b/filedir.tex @@ -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} diff --git a/filestd.tex b/filestd.tex index de338fe..9094ab3 100644 --- a/filestd.tex +++ b/filestd.tex @@ -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 diff --git a/fileunix.tex b/fileunix.tex index 1fe5a7e..10630c5 100644 --- a/fileunix.tex +++ b/fileunix.tex @@ -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. diff --git a/network.tex b/network.tex index 180d9aa..8240d45 100644 --- a/network.tex +++ b/network.tex @@ -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} diff --git a/process.tex b/process.tex index 4278133..d7d22cc 100644 --- a/process.tex +++ b/process.tex @@ -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} diff --git a/prochand.tex b/prochand.tex index 685827a..8c8a671 100644 --- a/prochand.tex +++ b/prochand.tex @@ -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 diff --git a/signal.tex b/signal.tex index f67c571..072b1d1 100644 --- a/signal.tex +++ b/signal.tex @@ -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 diff --git a/socket.tex b/socket.tex index 0efc4fd..ec88664 100644 --- a/socket.tex +++ b/socket.tex @@ -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 diff --git a/system.tex b/system.tex index bd5822b..6410f1a 100644 --- a/system.tex +++ b/system.tex @@ -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 -- 2.30.2