Provided by: manpages-fr-dev_4.18.1-1_all bug

NOM

       access, faccessat, faccessat2 - Vérifier les permissions utilisateur d'un fichier

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <unistd.h>

       int access(const char *chemin, int mode);

       #include <fcntl.h>            /* Définition des constantes AT_* */
       #include <unistd.h>

       int faccessat(int dirfd, const char *chemin, int mode, int argument);
                       /* Mais voir les différences entre la bibliothèque C
                          et le noyau ci-dessous. */

       #include <fcntl.h>            /* Définition des constantes AT_* */
       #include <sys/syscall.h>      /*  Définition des constantes
                                                     SYS_* */
       #include <unistd.h>

       int syscall(SYS_faccessat2,
                   int dirfd, const char *pathname, int mode, int flags);

   Exigences    de    macros    de   test   de   fonctionnalités   pour   la   glibc   (consulter
   feature_test_macros(7)) :

       faccessat() :
           Depuis la version 2.10 de la glibc :
               _POSIX_C_SOURCE >= 200809L
           Avant la version 2.10 de la glibc :
               _ATFILE_SOURCE

DESCRIPTION

       access() vérifie si le processus appelant peut accéder au fichier chemin. Si chemin est un
       lien symbolique, il est déréférencé.

       Le  mode  indique  les  vérifications  d'accès  à effectuer. Il prend la valeur F_OK ou un
       masque contenant un OU binaire d'une ou plus des valeurs R_OK, W_OK et  X_OK.  F_OK  teste
       l'existence  du  fichier.  R_OK,  W_OK  et X_OK testent si le fichier existe et autorisent
       respectivement la lecture, l'écriture et l'exécution.

       Le test est effectué avec les UID et GID réels du processus appelant, plutôt  qu'avec  les
       ID  effectifs  qui  sont  utilisés lorsque l'on tente une opération (comme open(2)) sur le
       fichier. De la même manière, pour le superutilisateur, le  test  utilise  un  ensemble  de
       capacités   permises   plutôt  que  l’ensemble  des  capacités  effectives,  et  pour  les
       utilisateurs non privilégiés, le test utilise un ensemble vierge de capacités.

       Cela permet aux programmes Setuid et dotés de capacités de déterminer les autorisations de
       l'utilisateur  ayant invoqué le programme. En d'autres termes, access() ne répond pas à la
       question  « puis-je  lire/écrire/exécuter  ce  fichier ? ».  Il  répond  à  une   question
       légèrement  différente :  « en  supposant que je suis un binaire Setuid, l'utilisateur qui
       m'a appelé peut-il lire/écrire/exécuter ce fichier ? », ce qui donne aux programmes Setuid
       la  possibilité  d'empêcher  des  utilisateurs  malveillants  de  lire  des fichiers qu'un
       utilisateur ne devrait pas lire.

       Si le processus appelant est privilégié (c'est-à-dire son UID réel est  zéro),  alors  une
       vérification  X_OK  réussit  pour  un  fichier  régulier  si  l'exécution est permise pour
       l'utilisateur propriétaire, le groupe ou pour les autres.

   faccessat()
       faccessat() opère exactement de la même manière  que  access(),  excepté  les  différences
       décrites ici.

       Si  le  nom  de  chemin  fourni dans chemin est relatif, il est interprété relativement au
       répertoire référencé par le descripteur de  fichier  dirfd  (plutôt  que  relativement  au
       répertoire de travail courant du processus appelant, comme cela est fait par access() pour
       un chemin relatif).

       Si chemin est relatif et que dirfd est la valeur spéciale AT_FDCWD, chemin est  interprété
       relativement au répertoire de travail courant du processus appelant (comme avec access()).

       Si pathname est absolu, alors dirfd est ignoré.

       argument  est  construit  en  réalisant  un OU logique entre zéro ou plusieurs des valeurs
       suivantes :

       AT_EACCESS
              Réaliser les vérifications d'accès en utilisant  les  UID  et  GID  effectifs.  Par
              défaut, faccessat() utilise les ID réels (comme access()).

       AT_SYMLINK_NOFOLLOW
              Si  chemin  est  un  lien  symbolique,  ne  pas  le déréférencer, mais renvoyer des
              informations sur le lien lui-même.

       Consultez openat(2) pour une explication sur la nécessité de faccessat().

   faccessat2()
       La description de faccessat() donnée ci-dessus correspond à POSIX.1 et à  l'implémentation
       fournie  dans  la  glibc.  Cependant,  l'implémentation  de  la  glibc était une émulation
       imparfaite (voir BOGUES) qui masquait le fait que  l'appel  système  faccessat()  brut  de
       Linux  n'a  pas de paramètre argument. Pour avoir une implémentation correcte, Linux 5.8 a
       ajouté l'appel système faccessat2() qui gère le paramètre argument  et  permet  une  bonne
       implémentation de la fonction enveloppe faccessat().

VALEUR RENVOYÉE

       En cas de succès (toutes les permissions demandées sont accordées, ou mode vaut F_OK et le
       fichier existe), 0 est renvoyé. En cas d'erreur (au  moins  une  permission  de  mode  est
       refusée,  ou  mode  vaut  F_OK  et  le  fichier  n'existe pas, ou d'autres erreurs se sont
       produites), -1 est renvoyé et errno est positionné pour indiquer l'erreur.

ERREURS

       EACCES L'accès est refusé au fichier lui‐même, ou il n'est pas permis  de  parcourir  l'un
              des répertoires du préfixe de chemin (consultez aussi path_resolution(7)).

       EBADF  (faccessat()) pathname est relatif mais dirfd ne vaut ni AT_FDCWD (faccessat()), ni
              un descripteur de fichier valable.

       EFAULT nom_chemin pointe en dehors de l'espace d'adressage accessible.

       EINVAL mode était mal indiqué.

       EINVAL (faccessat()) Attribut non valable indiqué dans flags.

       EIO    Une erreur d'entrée-sortie s'est produite.

       ELOOP  Trop de liens symboliques ont été rencontrés en parcourant nom_chemin.

       ENAMETOOLONG
              nom_chemin est trop long.

       ENOENT Un composant du chemin d'accès chemin  n'existe  pas  ou  est  un  lien  symbolique
              pointant nulle part.

       ENOMEM La mémoire disponible du noyau n'était pas suffisante.

       ENOTDIR
              Un  élément,  utilisé  comme  répertoire, du chemin d'accès nom_chemin n'est pas en
              fait un répertoire.

       ENOTDIR
              (faccessat()) pathname est relatif et dirfd est un descripteur de  fichier  faisant
              référence à un fichier qui n'est pas un dossier.

       EPERM  Une  écriture  est  demandée sur un fichier où un attribut immuable est positionné.
              Voir aussi ioctl_iflags(2).

       EROFS  Une écriture est demandée sur un système de fichiers en lecture seule.

       ETXTBSY
              Une  écriture  a  été  demandée  dans  un  fichier  exécutable  qui  est  en  cours
              d'utilisation.

VERSIONS

       faccessat()  a  été ajouté dans Linux 2.6.16 ; la prise en charge de la bibliothèque a été
       ajouté dans la glibc 2.4.

       faccessat2() a été ajouté à Linux 5.8.

STANDARDS

       access() : SVr4, 4.3BSD, POSIX.1-2001, POSIX.1-2008.

       faccessat() : POSIX.1-2008.

       faccessat2() : spécifique à Linux

NOTES

       Attention : Utiliser ces appels pour vérifier si un utilisateur a le droit,  par  exemple,
       d'ouvrir un fichier avant d'effectuer réellement l'ouverture avec open(2), risque de créer
       un trou de sécurité. En effet, l'utilisateur peut exploiter le petit intervalle  de  temps
       entre   la   vérification  et  l'accès  pour  modifier  le  fichier.  Pour  cette  raison,
       l'utilisation de cet appel système devrait être évitée (dans cet exemple, une  alternative
       plus  sûre  serait de basculer temporairement l'identifiant effectif de l'utilisateur vers
       l'identifiant réel et d'appeler open(2)).

       La fonction access() déréférence toujours les liens symboliques. Si vous  avez  besoin  de
       vérifier  les  droits  sur  un  lien  symbolique,  utilisez  faccessat(2)  avec l'attribut
       AT_SYMLINK_NOFOLLOW.

       Ces appels renvoient une erreur si l'un des types d'accès de  mode  est  refusé,  même  si
       d'autres types indiqués dans mode sont autorisés.

       Si  le processus appelant a les privilèges suffisants (c'est-à-dire est superutilisateur),
       POSIX.1-2001 permet à une implémentation d'indiquer un succès pour X_OK même si le fichier
       n'a aucun bit d'exécution positionné. Linux ne le permet pas.

       Un fichier n'est accessible que si les permissions de chacun des répertoires du préfixe du
       chemin  permettent  les  recherches  (c'est-à-dire  l'exécution).  Si  un  répertoire  est
       inaccessible,  alors  l'appel  à  access()  échouera, sans tenir compte des permissions du
       fichier lui-même.

       Seuls les bits d'accès sont vérifiés et non le type  ou  le  contenu  du  fichier.  Ainsi,
       l'autorisation d'écriture dans un répertoire indique probablement la possibilité d'y créer
       des fichiers et non d'y écrire comme dans un fichier. De même, un fichier  DOS  peut  être
       considéré comme exécutable, alors que l'appel execve(2) échouera toujours.

       Ces  appels peuvent fonctionner incorrectement sur un serveur NFSv2 si les correspondances
       d'UID sont activées, car ces correspondances sont gérées par le  serveur  et  masquées  au
       client  qui  effectue  les vérifications d'autorisation. Ces vérifications sont effectuées
       sur le serveur pour les versions 3 et supérieures de NFS. Des problèmes similaires peuvent
       survenir avec les montages FUSE.

   différences entre bibliothèque C et noyau
       L’appel système brut faccessat() n’accepte que les trois premiers arguments. Les attributs
       AT_EACCESS et AT_SYMLINK_NOFOLLOW sont en fait implémentés dans la fonction  enveloppe  de
       la  glibc  pour  faccessat().  Si  un  de ces attributs est indiqué, la fonction enveloppe
       utilise fstatat(2) pour déterminer les droits d'accès, mais voir BOGUES.

   Notes de la glibc
       Sur les anciens noyaux où  faccessat()  n'est  pas  disponible  (et  quand  les  attributs
       AT_EACCESS  et  AT_SYMLINK_NOFOLLOW  ne  sont  pas spécifiés), la fonction enveloppe de la
       glibc se rabat sur access(). Quand chemin est un chemin relatif,  la  glibc  construit  un
       chemin à partir du lien symbolique dans /proc/self/fd qui correspond au paramètre dirfd.

BOGUES

       L'appel système faccessat() du noyau Linux ne prenant pas en charge le paramètre argument,
       la fonction enveloppe faccessat() fournie  dans  la  glibc 2.32  et  antérieure  émule  la
       fonctionnalité  nécessaire  en utilisant une combinaison de l'appel système faccessat() et
       de fstatat(2). Mais cette émulation ne prend pas en charge les  ACL  (listes  de  contrôle
       d'accès).  À  partir  de  la glibc 2.33, la fonction enveloppe évite ce bogue en utilisant
       l'appel système faccessat2() là où il est fourni par le noyau sous-jacent.

       Dans Linux 2.4 (et auparavant) les  tests  X_OK  sont  gérés  de  façon  bizarre  pour  le
       superutilisateur. Si toutes les catégories de permission d'exécution sont désactivées pour
       un fichier (n'étant pas un répertoire), access() ne renvoie -1 que si le  mode  est  juste
       X_OK ;  si  R_OK  ou  W_OK  est également précisé dans le mode, access() renvoie 0 pour ce
       fichier. Les premiers Linux 2.6 (jusqu'à Linux 2.6.3) se comportaient de la même façon que
       Linux 2.4.

       Avant  Linux 2.6.20,  ces  appels  ignoraient  l'effet  de l'attribut MS_NOEXEC s'il était
       utilisé  pour  monter  le  système  de  fichiers  sous-jacent  (avec   mount(2)).   Depuis
       Linux 2.6.20, l'attribut MS_NOEXEC est pris en compte.

VOIR AUSSI

       chmod(2), chown(2), open(2), setgid(2), setuid(2), stat(2), euidaccess(3), credentials(7),
       path_resolution(7), symlink(7)

TRADUCTION

       La traduction française de cette  page  de  manuel  a  été  créée  par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,  Stéphan  Rafin  <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain  Portal  <aportal@univ-montp2.fr>,
       Jean-Philippe    Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-
       luc.coulon@wanadoo.fr>,   Julien    Cristau    <jcristau@debian.org>,    Thomas    Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,  Denis
       Barbier  <barbier@debian.org>,  David  Prévot <david@tilapin.org> et Jean-Philippe MENGUAL
       <jpmengual@debian.org>

       Cette traduction est une documentation libre ; veuillez vous reporter  à  la  GNU  General
       Public   License   version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩  concernant  les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.