/
attributs_fichiers.txt
163 lines (145 loc) · 8.7 KB
/
attributs_fichiers.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
ATTRIBUTS_FICHIERS
HEADER ==> #<sys/stat.h>
S_* TYPE FLAGS ==> #Il s'agit de flags que l'on teste avec le membre
#st_mode d'une struct stat, après application du masque
#S_IFMT (and'd), pour savoir le type désigné par ce
#st_mode. La valeur normale est entre parenthèses :
S_IFMT #Bit mask pour enlever les permissions bits de st_mode
#(0170000)
S_IFSOCK #Socket (0140000)
S_IFLNK #Symbolic link (0120000)
S_IFREG #Regular file (0100000)
S_IFBLK #Block device (0060000)
S_IFDIR #Directory (0040000)
S_IFCHR #Character device (0020000)
S_IFIFO #FIFO (0010000)
S_* ACCESS FLAGS ==> #Il s'agit de flags que l'on bitwise-or'd avec O_CREAT,
#désignant les droits d'accès du fichier créé. Ils sont
#ensuite bitwies-and'd avec l'umask. Ils sont utilisés
#par open(), mkdir() et stat()
S_ISVTX #1000 (sticky bit)
S_IRWXU #0700 (octal)
S_IRUSR #
S_IREAD #0400 (préferer le premier)
S_IWUSR #
S_IWRITE #0200 (préferer le premier)
S_IXUSR #
S_IEXEC #0100 (préferer le premier)
S_IRWXG #0070
S_IRGRP #0040
S_IWGRP #0020
S_IXGRP #0010
S_IRWXO #0007
S_IROTH #0004
S_IWOTH #0002
S_IXOTH #0001
HEADER ==> #<sys/stat.h>
mode_t #Type pour stocker des droits d'accès (en général UINT)
ino_t #Type pour stocker les numéros inode (en général
#ULONG_INT)
dev_t #Type pour stocker un numéro de device (en général INT),
#Il s'agit de la composition en un seul nombre du major
#ID et du minor ID du device.
nlink_t #Type pour stocker le nombre d'hard links (en général
#USHORT_INT)
blkcnt_t #Type pour stocker un nombre de blocks (en général
#ULONG_INT)
struct stat #Structure pour stocker les attributs d'un fichier.
#Ces membres sont :
STKT_STAT_VAR.st_mode #Permissions + type, sous forme octale, en mode_t.
#Les quatres derniers chiffre sont les permissions, les
#premiers sont le type. Il s'agit en fait d'un ensemble
#de flags commançant par S_ (type + permissions) or'd.
#Pour tester les permissions, faire donc un xor avec
#S_IFMT pour supprimer les bits de type.
#Pour tester le type, faire donc un and avec S_IFMT
#pour supprimer les bits de permissions.
STKT_STAT_VAR.st_ino #Numéro inode, sous forme d'ino_t
STKT_STAT_VAR.st_dev #Numéro du périphérique sous-jacent (= partition), sous
#forme de dev_t
STKT_STAT_VAR.st_rdev #Numéro du périphérique, lorsque le fichier est un
#special file. Les fichiers contenus sur ce périphérique
#auront le même st_dev que ce st_rdev. Renvoie 0 s'il ne
#s'agit pas d'un special file. Il s'agit d'un dev_t
STKT_STAT_VAR.st_nlink #Nombre d'hard links (1 pour un fichier régulier), sous
#forme de nlink_t
STKT_STAT_VAR.st_uid #UID du propriétaire
STKT_STAT_VAR.st_gid #GID du groupe propriétaire
STKT_STAT_VAR.st_atime #atime, sous forme de time_t
STKT_STAT_VAR.st_mtime #mtime, sous forme de time_t
STKT_STAT_VAR.st_ctime #ctime, sous forme de time_t
STKT_STAT_VAR.st_size #Taille apparente, en octets
STKT_STAT_VAR.st_blocks #Taille allouée, en blocks (512 octets souvent), sous
#forme de blkcnt_t.
STKT_STAT_VAR.st_blksize#Taille des blocks à utiliser lors des lecture/écriture
#pour optimiser la vitesse, en octets.
S_* MACROS ==> #Testent le type d'un MODE_T_VAL :
S_ISREG(MODE_T_VAL) #Equivaut à ((MODE_T_VAL & S_IFMT) == S_IFREG). Renvoie
#donc 1 si MODE_T_VAL désigne un fichier régulier, 0
#sinon
S_ISDIR(MODE_T_VAL) #Même chose pour les répertoires
S_ISCHR(MODE_T_VAL) #Même chose pour les character special files
S_ISBLK(MODE_T_VAL) #Même chose pour les block special files
S_ISFIFO(MODE_T_VAL) #Même chose pour les FIFO
S_ISLNK(MODE_T_VAL) #Même chose pour les liens symboliques
S_ISSOCK(MODE_T_VAL) #Même chose pour les sockets
S_TYPEISMQ(STK_STAT_ADR)#Renvoie 1 si STKT_STAT_VAR désigne un message queue,
#et 0 sinon
S_TYPEISSEM(SK_STAT_ADR)#Renvoie 1 si STKT_STAT_VAR désigne une sémaphore, et 0
#sinon
S_TYPEISSHM(SK_STAT_ADR)#Renvoie 1 si STKT_STAT_VAR désigne un shared memory
#object, et 0 sinon
stat(STR, STKT_STAT_ADR)#Enregistre les attributs du fichier dont le chemin est
#STR dans STKT_STAT_VAR
----| Renvoie 0 si succès, -1 si échec
fstat(INT_VAL, #Même chose, mais avec le file descriptor INT_VAL et non
STKT_STAT_ADR) #un chemin de fichier.
HEADER ==> #<sys/stat.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
lstat(STR, #
STKT_STAT_ADR) #Comme stat(), mais ne suit pas les symlinks
HEADER ==> #<unistd.h>
chown(STR, UID_T_VAL, #Fait que le fichier dont le chemin est STR a désormais
GID_T_VAL) #pour propriétaire l'user dont l'UID est UID_T_VAL, et
#comme groupe propriétaire le groupe dont le GID est
#GID_T_VAL. Si UID_T_VAL ou GID_T_VAL est -1, cela
#désigne l'actuel [groupe] propriétaire du fichier.
----| 0 si succès, -1 sinon
HEADER ==> #<unistd.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
fchown(INT_VAL, #Comme chown(), mais utilise non pas un chemin mais
UID_T_VAL, GID_T_VAL) #le file descriptor INT_VAL.
lchown(STR, UID_T_VAL, #
GID_T_VAL) #Comme chown(), mais ne déréférence pas les symlinks
HEADER ==> #<sys/stat.h>
chmod(STR, MODE_T_VAL) #Modifie les permissions du fichier dont le chemin est
#STR, par MODE_T_VAL (suite de S_ flags or'd). L'user
#doit avoir les permissions de le faire.
----| 0 si succès, -1 sinon
HEADER ==> #<sys/stat.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
fchmod(INT_VAL, #Comme chmod(), mais utilise plutôt un file descriptor
MODE_T_VAL) #INT_VAL.
----| 0 si succès, -1 sinon
HEADER ==> #<sys/stat.h>
umask(MODE_T_VAL) #Modifie l'umask courant pour qu'il devienne MODE_T_VAL
#(suite de flags commençant par S_ or'd)
----| Retourne le précédent umask
HEADER ==> #<unistd.h>
*_OK FLAGS ==> #Ces macros indiquent des permissions, utilisées par
#access()
F_OK #Le fichier existe
R_OK #Le fichier peut être lu par le RUID courant
W_OK #Le fichier peut être écrit par le RUID courant
X_OK #Le fichier peut être exécuté par le RUID courant
access(STR, INT_VAL) Teste si le RUID actuel peut faire l'action INT_VAL sur
#le fichier dont le chemin est STR. INT_VAL est un *_OK
#flag.
----| Renvoie 0 si succès, -1 si pas de permission.
| Ne doit être utilisé que dans le cas d'un SUID, car
| checke ici le RUID (et non l'EUID) ; or la plupart du
| temps c'est l'EUID qui doit être checké.
| Par ailleurs, éviter, car il y a des problèmes de
| sécurité.