listxattr(2) System Calls Manual listxattr(2) NOM listxattr, llistxattr, flistxattr - Lister les noms des attributs etendus BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include 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 etendus sont des paires nom:valeur associees aux inoeuds (fichiers, repertoires, liens symboliques, etc.). Ce sont des extensions des attributs normaux qui sont associes avec tous les inoeuds du systeme (les informations renvoyees par stat(2). Une description complete des concepts d'attributs etendus est disponible dans xattr(7). listxattr() recupere la liste des attributs etendus associes avec le chemin indique du systeme de fichier. La liste recuperee est placee dans liste, un tampon alloue par l'appelant, dont la taille (en octets) est indiquee dans l'argument taille. La liste est l'ensemble des noms (termines par NULL), l'un apres l'autre. Les noms des attributs etendus auxquels le processus appelant n'a pas acces peuvent etre omis dans la liste. La longueur de la liste de noms d'attributs est renvoyee. llistxattr() est identique a listxattr(), sauf dans le cas d'un lien symbolique, ou il renvoie la liste des noms des attributs associes au lien lui-meme et non au fichier auquel il se refere. flistxattr() est identique a listxattr(), sauf que le fichier ouvert associe au descripteur (fourni par open(2)) est interroge a la place du chemin. Le nom d'un attribut etendu est une simple chaine terminee par un octet NULL. Le nom inclut un prefixe d'espace de noms -- il peut y avoir plusieurs espaces de noms disjoints associes avec un inoeud particulier. Si taille est indique comme etant de zero, ces appels renvoient la taille actuelle de la liste des noms d'attributs etendus (et ils laissent liste inchangee). Cela peut etre utilise pour determiner la taille du tampon a fournir dans un appel consecutif (mais il faut tenir compte qu'il est possible que l'ensemble d'attributs etendus change entre deux appels et qu'il est donc necessaire de verifier le code de retour de nouveau lors du deuxieme appel). Exemple La liste des noms est renvoyee sous forme de table de chaines de caracteres terminees par un octet NULL, sans ordre particulier, les noms des attributs etant separes par des octets NULL ('\0')), comme ceci : user.name1\0system.name1\0user.name2\0 Les systemes de fichiers qui implementent les ACL (controles d'acces) POSIX en utilisant les attributs etendus peuvent renvoyer une liste comme celle-ci : system.posix_acl_access\0system.posix_acl_default\0 VALEUR RENVOYEE S'ils reussissent, ces appels renvoient un nombre non negatif correspondant a la taille de la liste de noms d'attributs. En cas d'echec, ils renvoient -1 et errno est defini pour indiquer l'erreur. ERREURS E2BIG La taille de la liste de noms d'attributs etendus est superieure a celle maximale autorisee ; la liste ne peut pas etre recuperee. Cela peut arriver sur des systemes de fichiers qui gerent un nombre illimite d'attributs etendus par fichier, tels que XFS par exemple. Voir BOGUES. ENOTSUP Les attributs etendus ne sont pas pris en charge par le systeme de fichiers ou sont desactives. ERANGE La taille du tampon de liste est trop petite pour contenir le resultat. De plus, les erreurs documentees dans stat(2) peuvent aussi survenir. STANDARDS Linux. HISTORIQUE Linux 2.4, glibc 2.3. BOGUES Comme indique dans xattr(7), le VFS impose une limite de 64 Ko comme taille de liste de noms d'attributs etendus renvoyee par listxattr(). Si la taille totale des noms d'attributs rattaches a un fichier depasse cette limite, il n'est plus possible de recuperer 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 parametre de la ligne de commande, il liste tous les attributs de fichier etendus et leur valeur. Pour garder un code simple, le programme suppose que les cles et les valeurs des attributs sont constantes pendant l'execution du programme. Un programme reel devrait prevoir et gerer des changements pendant son execution. Par exemple, le nombre d'octets requis pour les cles d'attributs peut augmenter entre les deux appels a listxattr(). Une application pourrait gerer cette eventualite en utilisant une boucle qui retente l'appel (peut-etre un nombre predetermine de fois) avec un tampon plus gros a chaque fois qu'il echoue avec l'erreur ERANGE. Les appels getxattr(2) pourraient etre geres de la meme maniere. La sortie suivante a ete enregistree lors de la premiere creation du fichier, ou certains attributs etendus ont ete positionnes, puis les attributs sont listes 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: Source du programme (listxattr.c) #include #include #include #include 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); } /* * Determiner la taille du tampon necessaire. */ 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 cles d'attributs dans le tampon. */ buflen = listxattr(argv[1], buf, buflen); if (buflen == -1) { perror("listxattr"); exit(EXIT_FAILURE); } /* * Boucle dans la liste de chaines finies par zero avec les cles * d'attribut. Utiliser le reste de la taille du tampon pour * determiner la fin de la liste. */ key = buf; while (buflen > 0) { /* * Afficher la cle d'attribut. */ printf("%s: ", key); /* * Determiner 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 supplementaire est necessaire pour completer 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(""); } printf("\n"); /* * Faire suivre a la prochaine cle 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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Jean-Philippe MENGUAL Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 listxattr(2)