po' piu` leggibili.
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
\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
\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
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
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}
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}
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
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
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}
\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
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
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}
\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
\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
\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
\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}.
\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
\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}.}
\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
\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
\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} è
\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},
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} è
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}
\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}}
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
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}
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
\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
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
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.
\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
\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.
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}
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
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
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
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
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
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.
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}
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
\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
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
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}
\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.}
\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
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:
\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
\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)}
\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.}
\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
\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}.
\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}.
\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
\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
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}
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
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
\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
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;
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}
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
projects / gapil.git / commitdiff