Provided by: manpages-fr-dev_4.13-4_all bug

NOM

       fts,  fts_open,  fts_read,  fts_children, fts_set, fts_close - Parcourir une hiérarchie de
       fichiers

SYNOPSIS

       #include <sys/types.h>
       #include <sys/stat.h>
       #include <fts.h>

       FTS *fts_open(char * const *path_argv, int options,
                     int (*compar)(const FTSENT **, const FTSENT **));

       FTSENT *fts_read(FTS *ftsp);

       FTSENT *fts_children(FTS *ftsp, int instr);

       int fts_set(FTS *ftsp, FTSENT *f, int instr);

       int fts_close(FTS *ftsp);

DESCRIPTION

       The fts functions are provided for traversing file hierarchies. A simple overview is  that
       the  fts_open()   function  returns  a  "handle"  (of  type  FTS *)  that refers to a file
       hierarchy "stream". This handle is then supplied to the other fts functions. The  function
       fts_read()   returns  a  pointer  to  a  structure describing one of the files in the file
       hierarchy. The function fts_children()  returns a pointer to a linked list of  structures,
       each of which describes one of the files contained in a directory in the hierarchy.

       In  general, directories are visited two distinguishable times; in preorder (before any of
       their descendants are visited) and in postorder (after all of their descendants have  been
       visited).  Files  are  visited  once.  It  is  possible  to walk the hierarchy "logically"
       (visiting the files that symbolic links point to)  or physically  (visiting  the  symbolic
       links themselves), order the walk of the hierarchy or prune and/or revisit portions of the
       hierarchy.

       Two structures (and associated types) are defined in the include file <fts.h>.  The  first
       type  is  FTS, the structure that represents the file hierarchy itself. The second type is
       FTSENT, the structure that represents a file in the file hierarchy.  Normally,  an  FTSENT
       structure  is  returned  for every file in the file hierarchy. In this manual page, "file"
       and "FTSENT structure" are generally interchangeable.

       The FTSENT structure contains fields describing a file. The structure  contains  at  least
       the following fields (there are additional fields that should be considered private to the
       implementation):

           typedef struct _ftsent {
               unsigned short  fts_info;     /* flags for FTSENT structure */
               char           *fts_accpath;  /* access path */
               char           *fts_path;     /* root path */
               short           fts_pathlen;  /* strlen(fts_path) +
                                                strlen(fts_name) */
               char           *fts_name;     /* filename */
               short           fts_namelen;  /* strlen(fts_name) */
               short           fts_level;    /* depth (-1 to N) */
               int             fts_errno;    /* file errno */
               long            fts_number;   /* local numeric value */
               void           *fts_pointer;  /* local address value */
               struct _ftsent *fts_parent;   /* parent directory */
               struct _ftsent *fts_link;     /* next file structure */
               struct _ftsent *fts_cycle;    /* cycle structure */
               struct stat    *fts_statp;    /* stat(2) information */
           } FTSENT;

       Les membres ont les significations suivantes :

       fts_info
              One of the following values describing the returned FTSENT structure and  the  file
              it  represents.  With  the  exception of directories without errors (FTS_D), all of
              these entries are terminal, that is, they will not be revisited, nor  will  any  of
              their descendants be visited.

              FTS_D  Un répertoire visité en phase « preorder ».

              FTS_DC Un   répertoire  introduisant  une  boucle  dans  l'arborescence.  Le  champ
                     fts_cycle de la structure FTSENT sera également remplis.

              FTS_DEFAULT
                     Toute  structure  FTSENT  représentant  un  type  de  fichier   non   décrit
                     explicitement par l'une des autres valeurs de fts_info.

              FTS_DNR
                     Un  répertoire  ne  pouvant être lu. C'est considéré comme une erreur, et le
                     champ fts_errno sera défini avec une valeur décrivant sa cause.

              FTS_DOT
                     Un fichier nommé « . » ou « .. » qui n'a pas été indiqué explicitement comme
                     argument de fts_open() (consultez FTS_SEEDOT).

              FTS_DP Un  répertoire  visité  en  phase  « postorder ». Le contenu de la structure
                     FTSENT ne sera pas différent de ce qu'il était après la phase  « preorder ».
                     C'est-à-dire quand le champ fts_info valait FTS_D.

              FTS_ERR
                     Il  s'agit  d'un  retour  d'erreur,  le  champ  fts_errno  étant rempli pour
                     indiquer la cause de l'erreur.

              FTS_F  Un fichier normal.

              FTS_NS Un fichier  pour  lequel  aucune  information  provenant  de  stat(2)  n'est
                     disponible.  Le  contenu du champ fts_statp est indéfini. Il s'agit d'un cas
                     d'erreur dont la cause est indiquée dans fts_errno.

              FTS_NSOK
                     Un fichier pour lequel aucune  information  provenant  de  stat(2)  n'a  été
                     demandée. Le contenu du champ fts_statp est indéfini.

              FTS_SL Un lien symbolique.

              FTS_SLNONE
                     Un  lien  symbolique  pointant  dans  le vide. Le contenu du champ fts_statp
                     contient les caractéristiques du lien lui-même.

       fts_accpath
              Un chemin permettant d'accéder au fichier depuis le répertoire courant.

       fts_path
              Le chemin d'accès au fichier à partir du point de départ du parcours.  Il  contient
              en préfixe le chemin fourni lors de l'invocation de fts_open().

       fts_pathlen
              The sum of the lengths of the strings referenced by fts_path and fts_name.

       fts_name
              Le nom du fichier.

       fts_namelen
              La longueur de la chaîne pointée par fts_name.

       fts_level
              La  profondeur où le fichier a été trouvé dans l'arborescence, numérotée de -1 à N.
              La structure FTSENT représentant le parent du point de départ est numérotée -1.  La
              structure FTSENT représentant la racine de départ elle-même est numérotée 0.

       fts_errno
              If  fts_children()  or fts_read()  returns an FTSENT structure whose fts_info field
              is set to FTS_DNR, FTS_ERR, or FTS_NS,  the  fts_errno  field  contains  the  error
              number  (i.e.,  the  errno value) specifying the cause of the error. Otherwise, the
              contents of the fts_errno field are undefined.

       fts_number
              Ce champ est mis à la disposition des programmes applicatifs, et n'est modifié  par
              aucune fonction de la famille fts. Il est toutefois initialisé à zéro.

       fts_pointer
              Ce  champ est mis à la disposition des programmes applicatifs, et n'est modifié par
              aucune fonction de la famille fts. Il est toutefois initialisé à NULL.

       fts_parent
              A pointer to the FTSENT structure referencing the file in the hierarchy immediately
              above  the  current  file, that is, the directory of which this file is a member. A
              parent structure for the initial entry point is provided as well, however, only the
              fts_level, fts_number, and fts_pointer fields are guaranteed to be initialized.

       fts_link
              Au  retour de la fonction fts_children(), le champ fts_link pointe sur la structure
              suivante dans la liste chaînée des membres du répertoires, liste  terminée  par  un
              NULL. Dans les autres situations, le contenu du champ fts_link est indéterminé.

       fts_cycle
              Si  un répertoire introduit une boucle dans la hiérarchie (consultez FTS_DC),soit à
              cause d'un lien physique entre deux répertoires, soit à cause d'un lien  symbolique
              pointant  vers  un répertoire, le champ fts_cycle pointera vers la structure FTSENT
              de la hiérarchie qui  référence  le  même  fichier  que  celui  représenté  par  la
              structure FTSENT. Sinon, le contenu du champ fts_cycle est indéfini.

       fts_statp
              Un pointeur vers les informations fournies par stat(2).

       Un  tampon  unique  est  utilisé  pour tous les chemins d'accès de tous les fichiers de la
       hiérarchie. Ainsi, les champs fts_path et fts_accpath sont assurés d'être terminés par  un
       caractère  nul  seulement  pour  le fichier renvoyé le plus récemment par fts_read(). Pour
       utiliser ces champs pour référencer un fichier représenté par une autre structure  FTSENT,
       il  faut  que  le  chemin  du tampon soit modifié avec l'information contenu dans le champ
       fts_pathlen de cette structure FTSENT. Tout autre modification devra  être  défaite  avant
       que  d'autres appels à fts_read() ne soient tentés. Le champ fts_name est toujours terminé
       par un caractère nul.

   fts_open()
       La fonction fts_open() reçoit  un  pointeur  vers  une  table  de  chaînes  de  caractères
       représentant  un  ou  plusieurs  chemins  décrivant la hiérarchie de fichiers à traverser.
       Cette table doit se terminer par un pointeur NULL.

       Il existe un certain nombre d'options, dont au moins une est obligatoire (soit FTS_LOGICAL
       ou  soit FTS_PHYSICAL). Les options sont sélectionnées par un ou logique entre les valeurs
       suivantes :

       FTS_COMFOLLOW
              Tout lien symbolique indiqué comme racine  du  parcours  sera  immédiatement  suivi
              (déréférencé), que l'option FTS_LOGICAL soit indiquée ou non.

       FTS_LOGICAL
              Cette option indique aux fonctions fts de renvoyer des structures FTSENT concernant
              les cibles des liens symboliques plutôt que les liens eux-mêmes. Avec cette option,
              les  seuls  liens  symboliques pour lesquels une structure FTSENT est renvoyée sont
              ceux pointant dans le vide. Il faut préciser soit FTS_LOGICAL, soit FTS_PHYSICAL  à
              la fonction fts_open().

       FTS_NOCHDIR
              Pour  optimiser les performances, les fonctions fts changent de répertoire au cours
              de la traversée de la hiérarchie de fichiers.  En  contrepartie,  l'application  ne
              peut  pas  savoir  à  l'avance  où  elle  se  trouve  durant la traversée. L'option
              FTS_NOCHDIR supprime cette optimisation et les fonctions fts ne changeront  pas  de
              répertoire  de  travail.  Remarquez  que  les  applications ne doivent pas modifier
              elles-même le répertoire de travail et essayer  d'accéder  aux  fichiers  sans  que
              l'option  FTS_NOCHDIR  ne  soit  indiquée et que des chemins d'accès absolus soient
              transmis à fts_open().

       FTS_NOSTAT
              Par défaut, les structures FTSENT renvoyées contiennent les caractéristiques  (voir
              le  champ  statp)  de  chaque fichier visité. Cette option relâche cette contrainte
              pour optimiser les performances, en autorisant les fonctions fts à remplir le champ
              fts_info avec FTS_NSOK et laisser le contenu du membre statp indéfini.

       FTS_PHYSICAL
              Avec  cette option, les routines fts renvoient des structures FTSENT pour les liens
              symboliques eux-mêmes et non pas les fichiers qu'ils pointent. Si cette option  est
              définie,  des  structures  FTSENT  pour tous les liens symboliques de la hiérarchie
              sont renvoyées à l'application. Soit FTS_LOGICAL ou  soit  FTS_PHYSICAL  doit  être
              fourni à la fonction fts_open().

       FTS_SEEDOT
              Par  défaut,  à  moins  d'être fournis explicitement en argument à fts_open() ,tout
              fichier nommé « . » ou « .. » rencontré dans la hiérarchie est ignoré.  Avec  cette
              option, les routines fts renvoient des structures FTSENT pour ces fichiers.

       FTS_XDEV
              Cette  option  empêche  fts  de  descendre  dans les répertoires se trouvant sur un
              périphérique différent de celui dans lequel le parcours a commencé.

       The argument compar()  specifies a user-defined function which may be used  to  order  the
       traversal  of  the  hierarchy.  It  takes two pointers to pointers to FTSENT structures as
       arguments and should return a negative value, zero, or a positive value to indicate if the
       file  referenced  by  its  first  argument  comes before, in any order with respect to, or
       after, the file  referenced  by  its  second  argument.  The  fts_accpath,  fts_path,  and
       fts_pathlen  fields  of the FTSENT structures may never be used in this comparison. If the
       fts_info field is set to FTS_NS or FTS_NSOK, the fts_statp field may not  either.  If  the
       compar()  argument  is  NULL,  the  directory  traversal  order  is in the order listed in
       path_argv for the root paths, and in the order listed  in  the  directory  for  everything
       else.

   fts_read()
       La  fonction  fts_read() renvoie un pointeur sur une structure FTSENT décrivant un fichier
       de la hiérarchie. Les répertoires lisibles et ne causant pas de boucles sont parcourus  au
       moins deux fois, une fois en phase « preorder », et une en phase « postorder ». Les autres
       fichiers ne sont examinés qu'une seule fois. Les liens physiques entre répertoires qui  ne
       causent  pas  de  boucles,  ou  les  liens  symboliques vers des liens symboliques peuvent
       entraîner des fichiers visités plus d'une fois, ou des répertoires plus de deux fois.

       Si tous les membres de la hiérarchie ont été examinés, fts_read() renvoie NULL et  définit
       la  variable  externe  errno  avec  un  0.  Si  une  erreur  sans  rapport avec un fichier
       particulier se produit, fts_read() renvoie NULL et définit errno en  conséquence.  Si  une
       erreur concernant le fichier en cours se produit, un pointeur sur une structure FTSENT est
       renvoyé, et errno peut ou non être défini (consultez fts_info).

       Les structures FTSENT renvoyées par fts_read() peuvent être  écrasées  après  un  appel  à
       fts_close()  sur  le  même descripteur de hiérarchie ou après un appel à fts_read() sur la
       même hiérarchie, sauf si elles représentent un répertoire, auquel cas elles ne seront  pas
       écrasées  avant  l'appel  fts_read()  renvoyant la structure FTSENT du répertoire en phase
       « postorder ».

   fts_children()
       La fonction fts_children() renvoie un pointeur  sur  une  structure  FTSENT  décrivant  la
       première  entrée  d'une liste chaînée terminée par un NULL et représentant les fichiers se
       trouvant dans le répertoire indiqué par la dernière structure FTSENT renvoyée par un appel
       fts_read().  La  liste est chaînée par le biais du membre fts_link de la structure FTSENT,
       et est ordonnée suivant la routine de  comparaison  fournie  par  l'utilisateur,  si  elle
       existe. Des appels répétés à fts_children() recréeront la liste chaînée.

       Un  cas  particulier  se  présente  si  fts_read()  n'a  pas  encore  été appelée pour une
       hiérarchie. Alors, fts_children() renverra un pointeur  sur  les  fichiers  du  répertoire
       logique  indiqué  dans fts_open(), c'est-à-dire les arguments fournis à fts_open(). Sinon,
       si la structure FTSENT la plus récemment renvoyée par fts_read() n'est pas  un  répertoire
       visité   en   phase   « preorder »,  ou  si  le  répertoire  ne  contient  aucun  fichier,
       fts_children() renvoie NULL et met la variable externe errno à  zéro.  Si  une  erreur  se
       produit, fts_children() renvoie NULL et définit errno en conséquence.

       The  FTSENT  structures  returned  by  fts_children()   may be overwritten after a call to
       fts_children(), fts_close(), or fts_read()  on the same file hierarchy stream.

       The instr argument is either zero or the following value:

       FTS_NAMEONLY
              Seuls les noms des fichiers sont nécessaires. Le contenu des membres des structures
              de la liste chaînée est indéfini sauf pour fts_name et fts_namelen.

   fts_set()
       The  function  fts_set()   allows the user application to determine further processing for
       the file f of the stream ftsp. The fts_set() function returns 0 on success, and -1  if  an
       error occurs.

       The instr argument is either 0 (meaning "do nothing") or one of the following values:

       FTS_AGAIN
              Revisiter  à nouveau le fichier. N'importe quel type de fichier peut être revisité.
              L'appel suivant de fts_read() renverra le fichier indiqué. Les membres fts_stat  et
              fts_info  de  la structure seront réinitialisés à ce moment, mais aucun autre champ
              ne sera modifié. Cette option n'a de sens que pour le dernier fichier  renvoyé  par
              fts_read().  L'utilisation habituelle de cette possibilité concerne les répertoires
              en phase « postorder », qui sont alors réexaminés (aussi bien en phase « preorder »
              que « postorder »), ainsi que leurs descendants.

       FTS_FOLLOW
              Le  fichier  référencé  doit  être un lien symbolique. Si ce fichier est le dernier
              renvoyé par fts_read(), alors l'appel suivant de fts_read()  renverra  le  fichier,
              avec  les  champs  fts_info et fts_statp réinitialisés pour représenter la cible du
              lien symbolique plutôt que le lien lui-même. Si le fichier est le  dernier  renvoyé
              par  fts_children(),  alors  les  membres  fts_info  et  fts_statp de la structure,
              lorsqu'elle  sera  renvoyée  par  fts_read(),  représenteront  la  cible  du   lien
              symbolique  plutôt  que  le  lien  lui-même. Dans tous les cas, si la cible du lien
              symbolique n'existe pas, les membres de la structure ne seront pas modifiés, et  le
              champ fts_info contiendra FTS_SLNONE.

              Si la cible du lien est un répertoire, il y aura un retour « preorder », suivi d'un
              retour pour chaque descendant, suivi d'un retour « postorder ».

       FTS_SKIP
              Aucun descendant de ce fichier ne sera visité. Le  fichier  doit  être  le  dernier
              renvoyé par fts_children() ou fts_read().

   fts_close()
       The  fts_close()   function  closes  the  file  hierarchy  stream  referred to by ftsp and
       restores the current directory to the directory from which fts_open()  was called to  open
       ftsp. The fts_close()  function returns 0 on success, and -1 if an error occurs.

ERREURS

       La fonction fts_open() peut échouer, et mettre dans errno l'une des erreurs indiquées pour
       les fonctions open(2) et malloc(3).

       La fonction fts_close() peut échouer, et mettre dans errno  l'une  des  erreurs  indiquées
       pour les fonctions chdir(2) et close(2).

       The functions fts_read()  and fts_children()  may fail and set errno for any of the errors
       specified for chdir(2), malloc(3), opendir(3), readdir(3), and stat(2).

       In addition, fts_children(), fts_open(), and fts_set()  may fail and set errno as follows:

       EINVAL options or instr was invalid.

VERSIONS

       Ces fonctions sont disponibles sous Linux depuis la glibc2.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌───────────────────────────────────┬──────────────────────┬───────────┐
       │InterfaceAttributValeur    │
       ├───────────────────────────────────┼──────────────────────┼───────────┤
       │fts_open(), fts_set(), fts_close() │ Sécurité des threads │ MT-Safe   │
       ├───────────────────────────────────┼──────────────────────┼───────────┤
       │fts_read(), fts_children()         │ Sécurité des threads │ MT-Unsafe │
       └───────────────────────────────────┴──────────────────────┴───────────┘

CONFORMITÉ

       4.4BSD.

BOGUES

       In versions of glibc before 2.23, all of the APIs described in this man page are not  safe
       when   compiling   a   program   using   the   LFS   APIs   (e.g.,   when  compiling  with
       -D_FILE_OFFSET_BITS=64).

VOIR AUSSI

       find(1), chdir(2), stat(2), ftw(3), qsort(3)

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux.  Une  description
       du  projet et des instructions pour signaler des anomalies et la dernière version de cette
       page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

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> et David Prévot <david@tilapin.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 ⟨⟩.