Ogni file ha anche un byte nel suo descrittore che specifica i
permessi di accesso ai vari utenti/processi del sistema. Tale byte è
contenuto nella struttura struct stat mostrata in figura
3.3.
Figura 3.3:
La struttura struct stat.
struct stat {
mode_t st_mode; /* file type + permission bits */
...
uid_t stuid; /* user ID */
gid_t st_gid; /* group ID*/
off_t st_size; /* size (in bytes) */
time_t st_atime; /* last access time */
time_t st_utime; /* last modif. time */
time_t st_ctime; /* last status change time */
};
Il campo st_mode contiene, nei vari bit, il tipo del file e i
permessi di accesso al file. I permessi di accesso sono l'OR
aritmetico delle seguenti costanti:
S_IRUSR, S_IWUSR, S_IXUSR
rispettivamente permessi di lettura,
scrittura ed esecuzione per il proprietario del file;
S_IRGRP, S_IWGRP, S_IXGRP
rispettivamente permessi di lettura,
scrittura ed esecuzione per gli utenti appartenenti al gruppo
di appartenenza del file.
S_IROTH, S_IWOTH, S_IXOTH
rispettivamente permessi di lettura,
scrittura ed esecuzione per tutti gli altri utenti del sistema.
Tramite il comando ls -l è possibile vedere i permessi di
accesso ai vari file, come mostrato in figura 3.4. In
particolare, la prima colonna a destra riassume lo stato dei bit del
campo st_mode:
il primo carattere indica il tipo del file (d sta per directory, - sta per un file normale);
i successivi caratteri, a gruppi di tre, indicano lo stato dei
permessi. I primi 3 indicano i permessi di accesso per il
proprietario, i secondi 3 i permessi di accesso per un utente dello
stesso gruppo, gli ultimi 3 per tutti gli altri.
Quindi ad esempio, il file unipi.gif è accessibile in lettura
e scrittura sia dal proprietario che dagli utenti del gruppo, mentre
è accessibile in sola lettura da tutti gli altri; la directory
dispense è accessibile in lettura ed esecuzione da tutti,
mentre è accessibile in scrittura solo dal proprietario o da un
utente dello stesso gruppo.
Figura 3.4:
Esempio di output del comando ls -l.
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
drwxrwxr-x 10 lipari lipari 4096 Nov 1 14:16 compiti
-rw-rw-r- 1 lipari lipari 16657 Oct 19 15:28 corso.png
drwxr-xr-x 3 lipari lipari 4096 Oct 29 17:46 dispense
-rw-rw-r- 1 lipari lipari 306631 Oct 29 17:46 dispense.ps
-rw-rw-r- 1 lipari lipari 77133 Oct 29 17:46 dispense.tgz
-rw-rw-r- 1 lipari lipari 4256 Nov 14 11:29 index.html
drwxrwxr-x 7 lipari lipari 4096 Nov 14 15:16 lezioni
-rw-rw-r- 1 lipari lipari 86856 Nov 20 11:13 lezioni.tgz
-rw-rw-r- 1 lipari lipari 4542 Oct 19 15:28 tesi.html
-rw-rw-r- 1 lipari lipari 2005 Oct 19 15:28 tesi.png
-rw-rw-r- 1 lipari lipari 3530 Oct 19 15:28 unipi.gif
Le regole di accesso ad un file sono quindi le seguenti:
Se vogliamo aprire un file (in lettura o in scrittura) dobbiamo
avere i permessi di esecuzione sulla directory in cui è
contenuto il file e su tutte le directory nel path.
Se vogliamo creare un file, dobbiamo avere i permessi in scrittura
ed esecuzione nella directory.
Se vogliamo cancellare un file non c'è bisogno di avere il permesso
di scrittura sul file, ma basta il permesso in scrittura ed esecuzione
sulla directory.
Per cambiare proprietario, gruppo e permessi a un file possiamo
utilizzare le funzioni chown() e chmod(). Da shell,
esistono i comandi chmod, chown e chgrp.
int chown(const char *pathname, uid_t owner, gid_t group);
int chmod(const char *pathname, mode_t mode);
Riferirsi alle man pages per la sintassi dei comandi di shell. Per
leggere la struttura stat di un file, si possono usare la primitive
fstat, stat o lstat:
int fstat(int filedes, struct stat *buf);
int stat(const char *file_name, struct stat *buf);
int lstat(const char *file_name, struct stat *buf);
