noble (2) flistxattr.2.gz

Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       listxattr, llistxattr, flistxattr - Lister les noms des attributs étendus

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <sys/xattr.h>

       ssize_t listxattr (const char *chemin, char *_Nullable liste, size_t taille);
       ssize_t llistxattr (const char *chemin, char *_Nullable liste, size_t taille);
       ssize_t flistxattr (int descripteur, char *_Nullable liste, size_t taille);

DESCRIPTION

       Les  attributs  étendus  sont  des  paires  nom:valeur  associées  aux  inœuds  (fichiers,
       répertoires, liens symboliques, etc.). Ce sont des extensions des  attributs  normaux  qui
       sont associés avec tous les inœuds du système (les informations renvoyées par stat(2). Une
       description complète des concepts d'attributs étendus est disponible dans xattr(7).

       listxattr() récupère la liste des attributs étendus associés avec  le  chemin  indiqué  du
       système  de  fichier.  La  liste  récupérée  est  placée  dans liste, un tampon alloué par
       l'appelant, dont la taille (en octets) est indiquée dans l'argument taille. La  liste  est
       l'ensemble  des  noms  (terminés  par  NULL),  l'un  après l'autre. Les noms des attributs
       étendus auxquels le processus appelant n'a pas accès peuvent être omis dans la  liste.  La
       longueur de la liste de noms d'attributs est renvoyée.

       llistxattr()  est  identique  à  listxattr(), sauf dans le cas d'un lien symbolique, où il
       renvoie la liste des noms des attributs associés au lien lui-même et non au fichier auquel
       il se réfère.

       flistxattr()  est  identique  à  listxattr(),  sauf  que  le  fichier  ouvert  associé  au
       descripteur (fourni par open(2)) est interrogé à la place du chemin.

       Le nom d'un attribut étendu est une simple chaîne terminée  par  un  octet  NULL.  Le  nom
       inclut  un  préfixe d'espace de noms — il peut y avoir plusieurs espaces de noms disjoints
       associés avec un inœud particulier.

       Si taille est indiqué comme étant de zéro, ces appels renvoient la taille actuelle  de  la
       liste  des  noms  d'attributs  étendus  (et  ils laissent liste inchangée). Cela peut être
       utilisé pour déterminer la taille du tampon à fournir dans un appel  consécutif  (mais  il
       faut  tenir compte qu'il est possible que l'ensemble d'attributs étendus change entre deux
       appels et qu’il est donc nécessaire de vérifier le code  de  retour  de  nouveau  lors  du
       deuxième appel).

   Exemple
       La  liste des noms est renvoyée sous forme de table de chaînes de caractères terminées par
       un octet NULL, sans ordre particulier, les noms des attributs étant séparés par des octets
       NULL ('\0')), comme ceci :

           user.name1\0system.name1\0user.name2\0

       Les  systèmes  de fichiers qui implémentent les ACL (contrôles d'accès) POSIX en utilisant
       les attributs étendus peuvent renvoyer une liste comme celle-ci :

           system.posix_acl_access\0system.posix_acl_default\0

VALEUR RENVOYÉE

       S'ils réussissent, ces appels renvoient un nombre non négatif correspondant à la taille de
       la  liste  de  noms d'attributs. En cas d'échec, ils renvoient -1 et errno est défini pour
       indiquer l'erreur.

ERREURS

       E2BIG  La taille de la liste de noms d'attributs étendus est supérieure à  celle  maximale
              autorisée ; la liste ne peut pas être récupérée. Cela peut arriver sur des systèmes
              de fichiers qui gèrent un nombre illimité d'attributs étendus par fichier, tels que
              XFS par exemple. Voir BOGUES.

       ENOTSUP
              Les attributs étendus ne sont pas pris en charge par le système de fichiers ou sont
              désactivés.

       ERANGE La taille du tampon de liste est trop petite pour contenir le résultat.

       De plus, les erreurs documentées dans stat(2) peuvent aussi survenir.

VERSIONS

       Ces appels système sont disponibles depuis Linux 2.4 ; la glibc les prend en charge depuis
       la glibc 2.3.

STANDARDS

       Ces appels système sont spécifiques à Linux.

BOGUES

       Comme  indiqué  dans  xattr(7), le VFS impose une limite de 64 Ko comme taille de liste de
       noms  d'attributs  étendus  renvoyée  par  listxattr().  Si  la  taille  totale  des  noms
       d'attributs  rattachés  à  un  fichier  dépasse  cette  limite,  il n'est plus possible de
       récupérer la liste des noms d'attributs.

EXEMPLES

       Le programme suivant montre l'utilisation  de  listxattr()  et  de  getxattr(2).  Pour  le
       fichier  dont le chemin est fourni en paramètre de la ligne de commande, il liste tous les
       attributs de fichier étendus et leur valeur.

       Pour garder un code simple, le programme suppose que les clés et les valeurs des attributs
       sont  constantes  pendant  l'exécution  du programme. Un programme réel devrait prévoir et
       gérer des changements pendant son exécution. Par exemple, le nombre d'octets  requis  pour
       les  clés  d'attributs peut augmenter entre les deux appels à listxattr(). Une application
       pourrait gérer cette éventualité en utilisant une boucle qui retente l'appel (peut-être un
       nombre  prédéterminé  de  fois)  avec  un tampon plus gros à chaque fois qu'il échoue avec
       l'erreur ERANGE. Les appels getxattr(2) pourraient être gérés de la même manière.

       La sortie suivante a été enregistrée lors de la première création du fichier, où  certains
       attributs  étendus ont été positionnés, puis les attributs sont listés avec cet exemple de
       programme.

   Sortie de l’exemple
           $ touch /tmp/foo
           $ setfattr -n user.fred -v chocolate /tmp/foo
           $ setfattr -n user.frieda -v bar /tmp/foo
           $ setfattr -n user.empty /tmp/foo
           $ ./listxattr /tmp/foo
           user.fred: chocolate
           user.frieda: bar
           user.empty: <no value>

   Source du programme (listxattr.c)
       #include <stdio.h>
       #include <stdlib.h>
       #include <string.h>
       #include <sys/xattr.h>

       int
       main(int argc, char *argv[])
       {
           char     *buf, *key, *val;
           ssize_t  buflen, keylen, vallen;

           if (argc != 2) {
               fprintf(stderr, "Usage : %s path\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           /*
            * Déterminer la taille du tampon nécessaire.
            */
           buflen = listxattr(argv[1], NULL, 0);
           if (buflen == -1) {
               perror("listxattr");
               exit(EXIT_FAILURE);
           }
           if (buflen == 0) {
               printf("%s n'a pas d'attributs.\n", argv[1]);
               exit(EXIT_SUCCESS);
           }

           /*
            * Allouer le tampon.
            */
           buf = malloc(buflen);
           if (buf == NULL) {
               perror("malloc");
               exit(EXIT_FAILURE);
           }

           /*
            * Copier la liste des clés d'attributs dans le tampon.
            */
           buflen = listxattr(argv[1], buf, buflen);
           if (buflen == -1) {
               perror("listxattr");
               exit(EXIT_FAILURE);
           }

           /*
            * Boucle dans la liste de chaînes finies par zéro avec les clés
            * d'attribut. Utiliser le reste de la taille du tampon pour
            * déterminer la fin de la liste.
            */
           key = buf;
           while (buflen > 0) {

               /*
                * Afficher la clé d'attribut.
                */
               printf("%s: ", key);

               /*
                * Déterminer la longueur de la valeur.
                */
               vallen = getxattr(argv[1], key, NULL, 0);
               if (vallen == -1)
                   perror("getxattr");

               if (vallen > 0) {

                   /*
                    * Allouer des tampons de valeur.
                    * Un octet supplémentaire est nécessaire pour compléter 0x00.
                    */
                   val = malloc(vallen + 1);
                   if (val == NULL) {
                       perror("malloc");
                       exit(EXIT_FAILURE);
                   }

                   /*
                    * Copier la valeur dans le tampon.
                    */
                   vallen = getxattr(argv[1], key, val, vallen);
                   if (vallen == -1) {
                       perror("getxattr");
                   } else {
                       /*
                       /*
                        * Afficher la valeur de l'attribut.
                        */
                       val[vallen] = 0;
                       printf("%s", val);
                   }

                   free(val);
               } else if (vallen == 0) {
                   printf("<pas de valeur>");
               }

               printf("\n");

               /*
                * Faire suivre à la prochaine clé d'attribut.
                */
               keylen = strlen(key) + 1;
               buflen -= keylen;
               key += keylen;
           }

           free(buf);
           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       getfattr(1), setfattr(1),  getxattr(2),  open(2),  removexattr(2),  setxattr(2),  stat(2),
       symlink(7), xattr(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⟩.