[gapil.git] / filedir.tex

\chapter{Files e directories}
\label{cha:files_and_dirs}

In questo capitolo tratteremo in dettaglio le varie caratteristiche di files e
directories, ed in particolare approfondiremo i dettagli su come è organizzata
la struttura dei files in un sistema unix; esamineremo poi come è strutturato
il sistema base di protezioni e controllo di accesso ai files, e tutta
l'interfaccia che permette la manipolazione dei vari attributi di files e
directories. Tutto quello che riguarda invece la manipolazione dei contenuti e
lasciato ai capitoli successivi.

Le funzioni che esamineremo in questo capitolo pertanto sono quelle che
permettono di creare e cancellare o leggere le directories, rinominare o
cancellare i files ed esaminare o cambiare i loro attributi.


\section{L'organizzazione di files e directories}
\label{sec:filedir_org}

L'organizzazione dei nomi dei file deriva direttamente dall'organizzazione dei
medesimi nell'albero descritto brevemente in \secref{sec:fileintr_overview};
una directory comunque, come già specificato in \secref{sec:fileintr_vfs}, è
solo un particolare tipo di file che contiene le informazioni che associano un
nome al contenuto. Per questo, anche se è usuale parlare di ``file in una
directory'' in realtà una directory contiene solo delle etichette per fare
riferimento ai file stessi.

I manuale delle librerie del C chiama i nomi contenuti nelle directory
\textsl{componenti} (in inglese \textit{file name components}), noi li
chiameremo più semplicemente nomi. Un file può essere indicato rispetto alla
directory corrente semplicemente specificando il nome da essa contenuto. Una
directory contiene semplicemente un elenco di questi nomi, che possono
corrispondere a un qualunque oggetto del filesystem, compresa un'altra
directory; l'albero viene appunto creato inserendo directory in altre
directory.

Il nome completo di file generico è composto da una serie di questi
\textsl{componenti} separati da una \texttt{/} (in linux più \texttt{/}
consecutive sono considerate equivalenti ad una sola). Il nome completo di un
file viene usualmente chiamato \textit{pathname}, e anche se il manuale della
glibc depreca questo nome (poichè genererebbe confusione, dato che con
\textit{path} si indica anche un insieme di directory su cui effettuare una
ricerca, come quello in cui si cercano i comandi) l'uso è ormai così comune
che è senz'altro più chiaro dell'alternativa proposta.

Il processo con cui si associa ad un pathname uno specifico file è chiamato
risoluzione del nome (\textit{file name resolution} o \textit{pathname
  resolution}).  La risoluzione viene fatta esaminando il pathname da destra a
sinistra e localizzando ogni nome nella directory indicata dal nome
precedente: ovviamente perché il procedimento funzioni occorre che i nomi
indicati come directory esistano e siano effettivamente directory, inoltre i
permessi devono consentire l'accesso.

Se il pathname comincia per \texttt{/} la ricerca parte dalla directory radice
del processo; questa, a meno di un \textit{chroot} (su cui torneremo in
seguito, vedi \secref{sec:proc_chroot}) è la stessa per tutti i processi ed
equivale alla directory radice dell'albero (come descritto in
\secref{sec:fileintr_overview}): in questo caso si parla di un pathname
\textsl{assoluto}. Altrimenti la ricerca parte dalla directory corrente (su
cui torneremo più avanti in \secref{sec:filedir_work_dir}) ed il pathname è
detto \textsl{relativo}.

I nomi \texttt{.} e \texttt{..} hanno un significato speciale e vengono
inseriti in ogni directory, il primo fa riferimento alla directory corrente e
il secondo alla directory \textsl{genitore} (\textit{parent directory}) cioè
la directory che contiene il riferimento alla directory corrente; nel caso
questa sia la directory radice allora il riferimento è a se stessa.


\section{La manipolazione di files e directories}
\label{sec:filedir_handling}

Per capire fino in fondo le proprietà di files e directories in un sistema
unix ed il funzionamento delle relative funzioni di manipolazione occorre una
breve introduzione agli oggetti su cui è basato un filesystem unix; in
particolare si riprenderà, approfondendolo sul piano dell'uso nelle funzioni
di libreria, il concetto di \textit{inode} di cui abbiamo brevemente accennato
le caratteristiche (dal lato dell'implementazione nel kernel) in
\secref{sec:fileintr_vfs}.


\subsection{Il funzionamento di un filesystem}
\label{sec:filedir_filesystem}

Come già accennato in \secref{sec:fileintr_overview} linux (ed ogni unix in
generale) organizza i dati che tiene su disco attraverso l'uso di un
filesystem. Una delle caratteristiche di linux rispetto agli altri unix è
quella di poter supportare grazie al VFS una enorme quantità di filesystem
diversi, ognuno dei quali ha una sua particolare struttura e funzionalità
proprie; per questo non entreremo nei dettagli di un filesystem specifico, ma
daremo una descrizione a grandi linee che si adatta alle caratteristiche
comuni di un qualunque filesystem standard unix.

Dato un disco lo spazio fisico viene usualmente diviso in partizioni; ogni
partizione può contenere un filesystem; quest'ultimo è in genere strutturato
secondo \nfig, con una lista di inodes all'inizio e il resto dello spazio a
disposizione per i dati e le directory.

\begin{figure}[htb]
  \centering
  
  \caption{Organizzazione dello spazio su un disco in partizioni e filesystem}
  \label{fig:filedir_disk_filesys}
\end{figure}

Se si va ad esaminare come è strutturata l'informazione all'interno di un
singolo filesystem (tralasciando le parti connesse alla strutturazione e al
funzionamento del filesystem stesso come il super-block) avremo una situazione
del tipo di quella esposta in \nfig.
\begin{figure}[htb]
  \centering
  
  \caption{Organizzazione di un filesystem}
  \label{fig:filedir_filesys_detail}
\end{figure}
da questa figura si evidenzano alcune caratteristiche su cui è bene porre
attenzione in quanto sono fondamentali per capire il funzionamento delle
funzioni che manipolano i file e le directory su cui torneremo fra poco; in
particolare è opportuno ricordare sempre che:

\begin{enumerate}
  
\item L'\textit{inode} contiene tutte le informazioni riguardanti il file: il
  tipo di file, i permessi di accesso, le dimensioni, i puntatori ai blocchi
  fisici che contengono i dati e così via; le informazioni che la funzione
  \texttt{stat} fornisce provengono dall'\textit{inode}; dentro una directory
  si troverà solo il nome del file e il numero dell'\textit{inode} ad esso
  associato, cioè quella che da qui in poi chiameremo una \textsl{voce}
  (traduzione approssimata dell'inglese \textit{directory entry}, che non
  useremo anche per evitare confusione con le \textit{dentries} del kernel di
  cui si parlava in \secref{sec:fileintr_vfs}).
  
\item Come mostrato in \curfig si possono avere più voci che puntano allo
  stesso \textit{inode}. Ogni \textit{inode} ha un contatore che contiene il
  numero di riferimenti (\textit{link count}) che sono stati fatti ad esso,
  solo quando questo contatore si annulla i dati del file vengono
  effettivamente rimossi dal disco. Per questo la funzione per cancellare un
  file si chiama \texttt{unlink}, ed in realtà non cancella affatto i dati del
  file, ma si limita a eliminare la relativa voce da una directory e
  decrementare il numero di riferimenti nell'\textit{inode}.
  
\item Il numero di \textit{inode} nella voce si riferisce ad un \textit{inode}
  nello stesso filesystem e non ci può essere una directory che contiene
  riferimenti ad \textit{inodes} relativi ad altri filesystem. Questo limita
  l'uso del comando \texttt{ln} (che crea una nuova voce per un file
  esistente, con la funzione \texttt{link}) al filesystem corrente.
  
\item Quando si cambia nome ad un file senza cambiare filesystem il contenuto
  del file non deve essere spostato, viene semplicemente creata una nuova voce
  per l'\textit{inode} in questione e rimossa la vecchia (questa è la modalità
  in cui opera normalmente il comando \texttt{mv} attraverso la funzione
  \texttt{rename}).

\end{enumerate}

Infine è bene avere presente che essendo file pure loro, esiste un numero di
riferimenti anche per le directories; per cui se ad esempio a partire dalla
situazione mostrata in \curfig\ creiamo una nuova directory \texttt{textdir}
nella directory corrente avremo una situazione come quella in \nfig, dove per
chiarezza abbiamo aggiunto dei numeri di inode.

La nuova directory avrà allora un numero di riferimenti pari a due, in quanto
è referenziata dalla directory da cui si era partiti (in cui è inserita la
nuova voce che fa riferimento a \texttt{textdir}) e dalla voce \texttt{.}
che è sempre inserita in ogni directory; questo vale sempre per ogni directory
che non contenga a sua volta altre directories. Al contempo la directory da
cui si era partiti avrà un numero di riferiementi di almeno tre, in quanto
adesso sarà referenziata anche dalla voce \texttt{..} di \texttt{textdir}.


\subsection{Le funzioni \texttt{link} e \texttt{unlink}}
\label{sec:filedir_link}

Una delle caratteristiche usate quando si opera con i file è quella di poter
creare dei nomi fittizi (alias o collegamenti) per potersi riferire allo
stesso file accedendovi da directory diverse. Questo è possibile anche in
ambiente unix, dove tali collegamenti sono usualmente chiamati \textit{link},
ma data la struttura del sistema ci sono due metodi sostanzialmente diversi
per fare questa operazione.

Come si è appena detto l'accesso al contenuto di un file su disco avviene
attraverso il suo inode, e il nome che si trova in una directory è solo una
etichetta associata ad un puntatore a detto inode.  Questo significa che la
realizzazione di un link è immediata in quanto uno stesso file può avere tanti
nomi diversi allo stesso tempo, dati da altrettante diverse associazioni allo
stesso inode; si noti poi che nessuno di questi nomi viene ad assumere una
particolare preferenza rispetto agli altri.

Per aggiungere un nome ad un inode si utilizza la funzione \texttt{link}; si
suole chiamare questo tipo di associazione un collegamento diretto (o
\textit{hard link}).  Il prototipo della funzione e le sue caratteritiche
principali, come risultano dalla man page, sono le seguenti:
\begin{prototype}{unistd.h}
{int link(const char * oldname, const char * newname)}
  Crea un nuovo collegamento diretto al file indicato da \texttt{oldname}
  dandogli nome \texttt{newname}.
  
  La funzione restituisce zero in caso di successo e -1 per un errore, in caso
  di errore. La variabile \texttt{errno} viene settata secondo i seguenti
  codici di errore:
  \begin{errlist}
  \item \texttt{EXDEV} \texttt{oldname} e \texttt{newname} non sono sullo
    stesso filesystem.
  \item \texttt{EPERM} il filesystem che contiene \texttt{oldname} e
    \texttt{newname} non supporta i link diretti.
  \item \texttt{EACCESS} 
    Non c'è il permesso di scrittura per la directory in cui si vuole creare
    il nuovo link.
  \item \texttt{EEXIST} Un file (o una directory) con quel nome esiste di
    già.
  \item \texttt{EMLINK} Ci sono troppi link al file \texttt{oldname} (il
    numero massimo è specificato dalla variabile \texttt{LINK\_MAX}, vedi
    \secref{sec:xxx_limits}.
  \item \texttt{ENOSPC} La directory in cui si vuole creare il link è piena e
    non può essere ampliata.
  \item \texttt{EROFS} La directory su cui si vuole inserire il nuovo link è
    su un filesystem montato readonly.
  \end{errlist}
\end{prototype}

La creazione di un nuovo collegamento diretto non copia il contenuto del file,
ma si limita ad aumentare di uno il numero di referenze al file aggiungendo il
nuovo nome ai precedenti. Si noti che uno stesso file può essere così
richiamato in diverse directory.
 
Per quanto dicevamo in \secref{sec:filedir_filesystem} la creazione del
collegamento diretto è possibile solo se entrambi i pathname sono nello stesso
filesytem; inoltre il filesystem deve supportare i collegamenti diretti (non è
il caso ad esempio del filesystem \texttt{vfat} di windows).

La funzione opera sui file ordinari, come sugli altri oggetti del filesystem,
ma solo l'amministratore è in grado di creare un collegamento diretto ad
un'altra directory, questo lo si fa perché in questo caso è possibile creare
dei cerchi nel filesystem (vedi \secref{sec:filedir_symlink}) che molti programmi
non sono in grado di gestire e la cui rimozione diventa estremamente
complicata (in genere occorre far girare il programma \texttt{fsck} per
riparare il filesystem).

La rimozione di un file (o più precisamente della voce che lo referenzia) si
effettua con la funzione \texttt{unlink}; il suo prototipo è il seguente:

\begin{prototype}{unistd.h}{int unlink(const char * filename)}
  Cancella il nome specificato dal pathname nella relativa directory e
  decrementa il numero di riferimenti nel relativo inode. Nel caso di link
  simbolico cancella il link simbolico; nel caso di socket, fifo o file di
  dispositivo rimuove il nome, ma come per i file i processi che hanno aperto
  uno di questi oggetti possono continuare ad utilizzarlo.
  
  La funzione restituisce zero in caso di successo e -1 per un errore, nel
  qual caso il file non viene toccato. La variabile \texttt{errno} viene
  settata secondo i seguenti codici di errore:
  \begin{errlist}
  \item \texttt{EACCESS} Non c'è il permesso di scrittura per la directory in
    cui si vuole creare il nuovo link o una delle directory del pathname non
    consente la ricerca (permesso di esecuzione).
  \item \texttt{EPERM} il pathname indica una directory o il filesystem che
    contiene \texttt{filename} non consente l'operazione.
  \item \texttt{EROFS} \texttt{filename} è su un filesystem montato in sola
    lettura.
  \item \texttt{EFAULT} la stringa \texttt{filename} è fuori dello spazio di
    indirizzi del processo.
  \item \texttt{ENAMETOOLONG} il pathname è troppo lungo.
  \item \texttt{ENOENT} Uno dei componenti del pathname non esiste o è un link
    simbolico spezzato.
  \item \texttt{ENOTDIR} Uno dei componenti del pathname non è una directory.
  \item \texttt{EISDIR} il pathname indica una directory.
  \item \texttt{ENOMEM} Memoria insufficiente nel kernel.
  \item \texttt{ELOOP} Ci sono troppi link simbolici nella risoluzione del
    pathname.
  \item \texttt{EIO} Errore di input/output.
  \end{errlist}
\end{prototype}

Per cancellare una voce in una directory è necessario avere il permesso di
scrittura su di essa (dato che si va a rimuovere una voce dal suo contenuto) e
il diritto di esecuzione sulla directory che la contiene (torneremo in
dettaglio sui permessi e gli attributi fra poco), se inoltre lo
\textit{sticky} bit è settato occorrerà anche essere proprietari del file o
proprietari della directory (o root, per cui nessuna delle restrizioni è
applicata).

Una delle caratteristiche di queste funzioni è che la creazione/rimozione
della nome dalla directory e l'incremento/decremento del numero di
riferimenti nell'inode deve essere una operazione atomica (cioè non
interrompibile da altri) processi, per questo entrambe queste funzioni sono
realizzate tramite una singola system call.

Si ricordi infine che il file non viene eliminato dal disco fintanto che tutti
i riferimenti ad esso sono stati cancellati, solo quando il \textit{link
  count} mantenuto nell'inode diventa zero lo spazio occupato viene rimosso. A
questo però si aggiunge una altra condizione, e cioè che non ci siano processi
che abbiano detto file aperto. Come accennato questa proprietà viene spesso
usata per essere sicuri di non lasciare file temporanei su disco in caso di
crash dei programmi; la tecnica è quella di aprire il file e chiamare
\texttt{unlink} subito dopo.

Al contrario di quanto avviene con altri unix in linux non è possibile usare
\texttt{unlink} per cancellare una directory



\subsection{Le funzioni \texttt{remove} e \texttt{rename}}
\label{sec:filedir_cre_canc}





\subsection{I link simbolici}
\label{sec:filedir_sym_link}

Siccome la funzione \texttt{link} crea riferimenti agli inodes, essa può
funzionare soltanto per file che risiedono sullo stesso filesystem, dato che
in questo caso è garantita l'unicità dell'inode, e solo per un filesystem di
tipo unix.  Inoltre in linux non è consentito eseguire un link diretto ad una
directory.

Per ovviare a queste limitazioni i sistemi unix supportano un'altra forma di
link (i cosiddetti \textit{soft link} o \textit{symbolic link}), che sono,
come avviene in altri sistemi operativi, dei file che contengono il
semplicemente il riferimento ad un altro file (o directory). In questo modo è
possibile effettuare link anche attraverso filesystem diversi e a directory, e
pure a file che non esistono ancora.

Il sistema funziona in quanto i link simbolici sono contrassegnati come tali
al kernel (analogamente a quanto avviene per le directory) per cui la chiamata
ad una \texttt{open} o una \texttt{stat} su un link simbolico comporta la
lettura del contenuto del medesimo e l'applicazione della funzione al file
specificato da quest'ultimo. Invece altre funzioni come quelle per cancellare
o rinominare i file operano direttamente sul link simbolico. Inoltre esistono
funzioni apposite, come la \texttt{readlink} e la \texttt{lstat} per accedere
alle informazioni del link invece che a quelle del file a cui esso fa
riferimento.

Le funzioni per operare sui link simbolici sono le seguenti, esse sono tutte
dichiarate nell'header file \texttt{unistd.h}.

\begin{prototype}{unistd.h}
{int symlink(const char * oldname, const char * newname)}
  Crea un nuovo link simbolico al file indicato da \texttt{oldname} dandogli
  nome \texttt{newname}.
  
  La funzione restituisce zero in caso di successo e -1 per un errore, in caso
  di errore. La variabile \texttt{errno} viene settata secondo i codici di
  errore standard di accesso ai files (trattati in dettaglio in
  \secref{sec:filedir_access_control}) ai quali si aggiungono i seguenti:
  \begin{errlist}
  \item \texttt{EEXIST} Un file (o una directory) con quel nome esiste di
    già.
  \item \texttt{EROFS} La directory su cui si vuole inserire il nuovo link è
    su un filesystem montato readonly.
  \item \texttt{ENOSPC} La directory o il filesystem in cui si vuole creare il
    link è piena e non c'è ulteriore spazio disponibile.
  \item \texttt{ELOOP} Ci sono troppi link simbolici nella risoluzione di
    \texttt{oldname} o di \texttt{newname}.
  \end{errlist}
\end{prototype}


\subsection{Le funzioni \texttt{mkdir} e \texttt{rmdir}} 
\label{sec:filedir_dir_creat_rem}

Per creare una nuova directory si può usare la seguente funzione, omonima
dell'analogo comando di shell \texttt{mkdir}; per accedere ai tipi usati 
programma deve includere il file \texttt{sys/types.h}.

\begin{prototype}{sys/stat.h}
{int mkdir (const char * dirname, mode\_t mode)}
  Questa funzione crea una nuova directory vuota con il nome indicato da
  \texttt{dirname}, assegnandole i permessi indicati da \texttt{mode}. Il nome
  può essere indicato con il pathname assoluto o relativo.
  
  La funzione restituisce zero in caso di successo e -1 per un errore, in caso
  di errore \texttt{errno} viene settata secondo i codici di errore standard
  di accesso ai files (trattati in dettaglio in
  \secref{sec:filedir_access_control}) ai quali si aggiungono i seguenti:
  \begin{errlist}
  \item \texttt{EACCESS} 
    Non c'è il permesso di scrittura per la directory in cui si vuole inserire
    la nuova directory.
  \item \texttt{EEXIST} Un file (o una directory) con quel nome essite di già. 
  \item \texttt{EMLINK} La directory in cui si vuole creare la nuova directory
    contiene troppi file. Sotto linux questo normalmente non avviene perchè il
    filesystem standard consente la creazione di un numero di file maggiore di
    quelli che possono essere contenuti nell'hard-disk, ma potendo avere a che
    fare anche con filesystem di altri sistemi questo errore può presentarsi.
  \item \texttt{ENOSPC} Non c'è abbastanza spazio sul file system per creare
    la nuova directory.
  \item \texttt{EROFS} La directory su cui si vuole inserire la nuova
    directory è su un filesystem montato readonly.
  \end{errlist}
\end{prototype}
 

\subsection{Accesso alle directory}
\label{sec:filedir_dir_read}

Benchè le directory siano oggetti del filesystem come tutti gli altri non ha
ovviamente senso aprirle come fossero dei file di dati. Può però essere utile
poterne leggere il contenuto ad esempio per fare la lista dei file che esse
contengono o ricerche sui medesimi.

Per accedere al contenuto delle directory si usano i cosiddetti
\textit{directory streams} (chiamati così per l'analogia con i file stream);
la funzione \texttt{opendir} apre uno di questi stream e la funzione
\texttt{readdir} legge il contenuto della directory, i cui elementi sono le
\textit{directory entries} (da distinguersi da quelle della cache di cui
parlavamo in \secref{sec:fileintr_vfs}) in una opportuna struttura
\texttt{struct dirent}.


\subsection{La directory di lavoro}
\label{sec:filedir_work_dir}

A ciascun processo è associato ad una directory nel filesystem che è chiamata
directory corrente o directory di lavoro (\textit{current working directory})
che è quella a cui si fa riferimento quando un filename è espresso in forma
relativa (relativa appunto a questa directory).

Quando un utente effettua il login questa directory viene settata alla
cosiddetta \textit{home directory} del suo account, il comando \texttt{cd}
della shell consente di cambiarla a piacere, spostandosi da una directory ad
un'altra.  Siccome la directory corrente resta la stessa quando viene creato
un processo figlio, la directory corrente della shell diventa anche la
directory corrente di qualunque comando da essa lanciato.

Le funzioni qui descritte servono esaminare e cambiare la directory di lavoro
corrente. 

\begin{prototype}{unistd.h}{char * getcwd (char * buffer, size\_t size)}
  Restituisce il filename completo della directory di lavoro corrente nella
  stringa puntata da \texttt{buffer}, che deve essere precedentemente
  allocata, per una dimensione massima di \texttt{size}. Si può anche
  specificare un puntatore nullo come \textit{buffer}, nel qual caso la
  stringa sarà allocata automaticamente per una dimensione pari a
  \texttt{size} qualora questa sia diversa da zero, o della lunghezza esatta
  del pathname altrimenti. In questo caso si deve ricordare di disallocara la
  stringa una volta cessato il suo utilizzo.
  
  La funzione restituisce il puntatore \texttt{buffer} se riesce,
  \texttt{NULL} se fallisce, in quest'ultimo caso la variabile
  \texttt{errno} è settata con i seguenti codici di errore:
  \begin{errlist}
  \item \texttt{EINVAL} L'argomento \texttt{size} è zero e \texttt{buffer} non
    è nullo.
  \item \texttt{ERANGE} L'argomento \texttt{size} è più piccolo della
    lunghezza del pathname. 
  \item \texttt{EACCES} Manca il permesso di lettura o di ricerca su uno dei
    componenti del pathname (cioè su una delle directory superiori alla
    corrente).
  \end{errlist}
\end{prototype}

Di questa funzione esiste una versione \texttt{char * getwd(char * buffer)}
fatta per compatibilità all'indietro con BSD, che non consente di specificare
la dimensione del buffer; esso deve essere allocato in precedenza ed avere una
dimensione superiore a \texttt{PATH\_MAX} (di solito 256 byters, vedi
\secref{sec:xxx_limits}; il problema è che in linux non esiste una dimensione
superiore per un pathname, per cui non è detto che il buffer sia sufficiente a
contenere il nome del file, e questa è la ragione principale per cui questa
funzione è deprecata.

Una seconda funzione simile è \texttt{char * get\_current\_dir\_name(void)}
che è sostanzialmente equivalente ad una \texttt{getcwd(NULL, 0)}, con la sola
differenza che essa ritorna il valore della variabile di ambiente
\texttt{PWD}, che essendo costruita dalla shell può contenere anche dei
riferimenti simbolici.

Come già detto in unix anche le directory sono file, è possibile pertanto
riferirsi ad esse tramite il file descriptor dell'interfaccia a basso livello,
e non solo tramite il filename; per questo motivo ci sono due diverse funzioni
per cambiare directory di lavoro.

\begin{prototype}{unistd.h}{int chdir (const char * pathname)}
  Come dice il nome (che significa \textit{change directory}) questa funzione
  serve a cambiare la directory di lavoro a quella speficata dal pathname
  contenuto nella stringa \texttt{pathname}.
\end{prototype}
  
\begin{prototype}{unistd.h}{int fchdir (int filedes)} 
  Analoga alla precedente, ma usa un file descriptor invece del pathname.
  
  Entrambe le funzioni restituiscono zero in caso di successo e -1 per un
  errore, in caso di errore \texttt{errno} viene settata secondo i codici di
  errore standard di accesso ai files (trattati in dettaglio in
  \secref{sec:filedir_access_control}) ai quali si aggiunge il codice
  \texttt{ENOTDIR} nel caso il \texttt{filename} indichi un file che non sia
  una directory.
\end{prototype}





\section{La manipolazione delle caratteristiche dei files}
\label{sec:filedir_infos}




\subsection{Le funzioni \texttt{stat}, \texttt{fstat} e \texttt{lstat}}
\label{sec:filedir_stat}

\subsection{I tipi di file}
\label{sec:filedir_file_types}

\subsection{La dimensione dei file}
\label{sec:filedir_file_size}

\subsection{I tempi dei file}
\label{sec:filedir_file_times}

\subsection{La funzione \texttt{utime}}
\label{sec:filedir_utime}



\section{Il controllo di accesso ai file}
\label{sec:filedir_access_control}


\subsection{I flag \texttt{suid} e \texttt{sgid}}
\label{sec:filedir_suid_sgid}

\subsection{La titolarità di nuovi files e directory}
\label{sec:filedir_ownership}

\subsection{La funzione \texttt{access}}
\label{sec:filedir_access}

\subsection{La funzione \texttt{umask}}
\label{sec:filedir_umask}

\subsection{Le funzioni \texttt{chmod} e \texttt{fchmod}}
\label{sec:filedir_chmod}

\subsection{Il flag \texttt{stiky}}
\label{sec:filedir_stiky}

\subsection{Le funzioni \texttt{chown}, \texttt{fchown} e \texttt{lchown}}
\label{sec:filedir_chown}



%La struttura fondamentale che contiene i dati essenziali relativi ai file è il
%cosiddetto \textit{inode}; questo conterrà informazioni come il
%tipo di file (file di dispositivo, directory, file di dati, per un elenco
%completo vedi \ntab), i permessi (vedi \secref{sec:file_perms}), le date (vedi
%\secref{sec:file_times}).