\begin{verbatim}
$ln -s /tmp/tmp_file temporaneo
\end{verbatim}%$
-ma anche se \file{/tmp/tmp_file} non esiste. Aprendo in scrittura
+ma anche se \file{/tmp/tmp\_file} non esiste. Aprendo in scrittura
\file{temporaneo} questo verrà scritto; ma se cercassimo di accederlo in sola
lettura (ad esempio con \cmd{cat}) otterremmo:
\begin{verbatim}
\footnotesize
\centering
\begin{minipage}[c]{15cm}
- \begin{lstlisting}[]{}
+ \begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
struct stat {
dev_t st_dev; /* device */
ino_t st_ino; /* inode */
effettuare delle selezioni sul tipo di file voluto, combinando opportunamente
i vari flag; ad esempio se si volesse controllare se un file è una directory o
un file ordinario si potrebbe definire la condizione:
-\begin{lstlisting}
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
#define IS_FILE_DIR(x) ( ((x) & S_IFMT) & (S_IFDIR | S_IFREG) )
\end{lstlisting}
in cui prima si estraggono da \var{st\_mode} i bit relativi al tipo di file e
Il sistema mantiene per ciascun file tre tempi. Questi sono registrati
nell'inode insieme agli altri attibuti del file e possono essere letti tramite
la funzione \func{stat}, che li restituisce attraverso tre campi della
-struttura in \figref{fig:filedir_stat_struct} il cui signifato è riportato
-nello schema in \ntab:
+struttura in \figref{fig:filedir_stat_struct}. Il significato di detti tempi e
+dei relativi campi è riportato nello schema in \ntab:
\begin{table}[htb]
\centering
\begin{tabular}[c]{|c|l|l|c|}
+ \hline
+ Membro & Significato & Funzione&opzione \\
+ \hline
+ \hline
\var{st\_atime}& ultimo accesso ai dati del file &\func{read}& \cmd{-u}\\
\var{st\_mtime}& ultima modifica ai dati del file &\func{write}& default\\
\var{st\_ctime}& ultima modifica ai dati dell'inode&\func{chmod},
\func{utime} & \cmd{-c} \\
+ \hline
\end{tabular}
\caption{I tre tempi associati a ciascun file}
\label{tab:filedir_file_times}
\end{table}
-
-La differenza principale di cui tenere presente è quella fra tempo di modifica
-\var{st\_mtime} e tempo di cambiamento di stato \var{st\_ctime}. Il primo
+Il primo punto da tenere presente è la differenza fra il cosiddetto tempo di
+modifica (il \textit{modification time} \var{st\_mtime}) e il tempo di
+cambiamento di stato (il \textit{chage time} \var{st\_ctime}). Il primo
infatti fa riferimento ad una modifica del contenuto di un file, mentre il
secondo ad una modifica dell'inode; siccome esistono molte operazioni (come la
funzione \func{link} e molte altre che vedremo in seguito) che modificano solo
-le informazioni contenute nell'inode senza toccare il file, dato che queste
-ultime sono separate dal contenuto del file diventa necessario l'utilizzo di
-un altro tempo. Si noti inoltre come \var{st\_ctime} non abbia nulla a che
-fare con il tempo di creazione usato da molti altri sistemi operativi, che in
-unix non esiste.
+le informazioni contenute nell'inode senza toccare il file, diventa necessario
+l'utilizzo di un altro tempo.
+
+Il sistema non tiene conto dell'ultimo accesso all'inode, pertanto funzioni
+come \func{access} o \func{stat} non hanno alcuna influenza sui tre tempi. Il
+tempo di ultimo accesso viene di solito usato per cancellare i file che non
+servono più dopo un certo lasso di tempo (ad esempio \cmd{leafnode} cancella i
+vecchi articoli sulla base di questo tempo).
+
+Il tempo di ultima modifica invece viene usato da \cmd{make} per decidere
+quali file necessitano di essere ricompilati o (talvolta insieme anche al
+tempo di cambiamento di stato) per decidere quali file devono essere
+archiviati per il backup. Il comando \cmd{ls} (quando usato con le opzioni
+\cmd{-l} o \cmd{-t}) mostra i tempi dei file secondo lo schema riportato
+nell'ultima colonna di \curtab.
+
+L'effetto delle varie funzioni di manipolazione dei file sui tempi è
+illustrato in \ntab. Si sono riportati gli effetti sia per il file a cui si fa
+riferimento, sia per la directory che lo contiene; questi ultimi possono
+essere capiti se si tiene conto di quanto già detto, e cioè che anche le
+directory sono files, che il sistema tratta in maniera del tutto analoga agli
+altri.
+
+Per questo motivo tutte le volte che compiremo una operazione su un file che
+comporta una modifica della sua directory entry, andremo anche a scrivere
+sulla directory che lo contiene cambiandone il tempo di modifica. Un esempio
+di questo può essere la cancellazione di un file, mentre leggere o scrivere o
+cambiarne i permessi ha effetti solo sui tempi del file.
+\begin{table}[htb]
+ \centering
+ \footnotesize
+ \begin{tabular}[c]{|l|c|c|c|c|c|c|l|}
+ \hline
+ \multicolumn{1}{|c|}{Funzione}
+ &\multicolumn{3}{p{2cm}}{File o directory di riferimento}
+ &\multicolumn{3}{p{2cm}}{Directory genitrice del riferimento}
+ &\multicolumn{1}{|c|}{Note} \\
+ \cline{2-7}
+ & \textsl{(a)} & \textsl{(m)}& \textsl{(c)}
+ & \textsl{(a)} & \textsl{(m)}& \textsl{(c)}& \\
+ \hline
+ \hline
+ \func{chmod}, \func{fchmod}
+ & & &$\bullet$& & & & \\
+ \func{chown}, \func{fchown}
+ & & &$\bullet$& & & & \\
+ \func{creat}
+ &$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& con
+ \macro{O\_CREATE} \\ \func{creat}
+ & &$\bullet$&$\bullet$& &$\bullet$&$\bullet$&
+ con \macro{O\_TRUNC} \\ \func{exec}
+ &$\bullet$& & & & & & \\
+ \func{lchown}
+ & & &$\bullet$& & & & \\
+ \func{link}
+ & & &$\bullet$& &$\bullet$&$\bullet$& \\
+ \func{mkdir}
+ &$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& \\
+ \func{mkfifo}
+ &$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& \\
+ \func{open}
+ &$\bullet$&$\bullet$&$\bullet$& &$\bullet$&$\bullet$& con
+ \macro{O\_CREATE} \\ \func{open}
+ & &$\bullet$&$\bullet$& & & & con
+ \macro{O\_TRUNC} \\ \func{pipe}
+ &$\bullet$&$\bullet$&$\bullet$& & & & \\
+ \func{read}
+ &$\bullet$& & & & & & \\
+ \func{remove}
+ & & &$\bullet$& &$\bullet$&$\bullet$& using
+ \func{unlink}\\ \func{remove}
+ & & & & &$\bullet$&$\bullet$& using
+ \func{rmdir}\\ \func{rename}
+ & & &$\bullet$& &$\bullet$&$\bullet$& per entrambi
+ gli argomenti\\ \func{rmdir}
+ & & & & &$\bullet$&$\bullet$& \\
+ \func{truncate}, \func{ftruncate}
+ & &$\bullet$&$\bullet$& & & & \\
+ \func{unlink}
+ & & &$\bullet$& &$\bullet$&$\bullet$& \\
+ \func{utime}
+ &$\bullet$&$\bullet$&$\bullet$& & & & \\
+ \func{write}
+ & &$\bullet$&$\bullet$& & & & \\
+ \hline
+ \end{tabular}
+ \caption{Effetti delle varie funzioni su tempi di ultimo accesso
+ \textsl{(a)}, ultima modifica \textsl{(m)} e ultimo cambiamento
+ \textsl{(c)}}
+ \label{tab:filedir_times_effects}
+\end{table}
+Si noti infine come \var{st\_ctime} non abbia nulla a che fare con il tempo di
+creazione del file usato da molti altri sistemi operativi, che in unix non
+esiste.
\subsection{La funzione \texttt{utime}}
\label{sec:filedir_utime}
+I tempi di ultimo accesso e modifica possono essere cambiati usando la
+funzione \func{utime}, il cui prototipo è:
+
+\begin{prototype}{utime.h}
+{int utime(const char * filename, struct utimbuf *times)}
+
+Cambia i tempi di ultimo accesso e modifica dell'inode specificato da
+\var{filename} secondo i campi \var{actime} e \var{modtime} di \var{times}. Se
+questa è \macro{NULL} allora viene usato il tempo corrente.
+
+La funzione restituisce zero in caso di successo e -1 in caso di errore, nel
+qual caso \var{errno} è settata opportunamente.
+\begin{errlist}
+\item \texttt{EACCESS} non si ha il permesso di scrittura sul file.
+\item \texttt{ENOENT} \var{filename} non esiste.
+\end{errlist}
+\end{prototype}
+
+La struttura \var{utimebuf} usata da \func{utime} è definita come:
+\begin{lstlisting}[labelstep=0,frame=,indent=1cm]{}
+struct utimbuf {
+ time_t actime; /* access time */
+ time_t modtime; /* modification time */
+};
+\end{lstlisting}
+
+L'effetto della funzione e i privilegi necessari per eseguirla dipendono da
+cosa è l'argomento \var{times}; se è \textit{NULL} la funzione setta il tempo
+corrente ed è sufficiente avere accesso in scrittura al file; se invece si è
+specificato un valore la funzione avrà successo solo se si è proprietari del
+file (o si hanno i privilegi di amministratore).
+Si tenga presente che non è comunque possibile specificare il tempo di
+cambiamento di stato del file, che viene comunque cambiato dal kernel tutte le
+volte che si modifica l'inode (quindi anche alla chiamata di \func{utime}).
+Questo serve anche come misura di sicurezza per evitare che si possa
+modificare un file nascondendo completamente le proprie tracce. In realtà la
+cosa resta possibile, se si è in grado di accedere al device, scrivendo
+direttamente sul disco senza passare attraverso il filesystem, ma ovviamente è
+molto più complicato da realizzare.
\section{Il controllo di accesso ai file}
\label{sec:filedir_access_control}
-
In unix è implementata da qualunque filesystem standard una forma elementare
(ma adatta alla maggior parte delle esigenze) di controllo di accesso ai
files. Torneremo sull'argomento in dettaglio più avanti (vedi
% elementare qui; inoltre ad un processo sono associati diversi identificatori,
% torneremo su questo in maggiori dettagli in seguito in \secref{sec:proc_perms}.
-
-
\subsection{I flag \texttt{suid} e \texttt{sgid}}
\label{sec:filedir_suid_sgid}
projects / gapil.git / blobdiff