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⟩.