perkamon - en to fr translation catalogue (165 entries)

note: type: TH
en: 2008-09-23
fr: 23 septembre 2008

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: closedir - close a directory
fr: closedir - Fermer un répertoire

note: type: Plain text
en: The B<closedir>()  function closes the directory stream associated with I<dirp>.  A successful call to B<closedir>()  also closes the underlying file descriptor associated with I<dirp>.  The directory stream descriptor I<dirp> is not available after this call.
fr: La fonction B<closedir>() ferme le flux du répertoire associé à I<dirp>. Un appel réussi à B<closedir>() ferme aussi le descripteur de fichier sous-jacent associé à I<dirp>. Après cet appel, le descripteur I<dirp> du flux du répertoire n'est plus disponible.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<closedir>()  function returns 0 on success.  On error, -1 is returned, and I<errno> is set appropriately.
fr: En cas de succès, la fonction B<closedir>() renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> est définie en conséquence.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Invalid directory stream descriptor I<dirp>.
fr: Le descripteur de flux du répertoire, I<dirp>, n'est pas valable.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD.
fr: SVr4, POSIX.1-2001, BSD 4.3.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2013-07-05
fr: 5 juillet 2013

note: type: Plain text
en: dirfd - get directory stream file descriptor
fr: dirfd - Obtenir un descripteur de fichier d'un répertoire

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<dirfd>():
fr: B<dirfd>() :

note: type: Plain text
en: || /* Since glibc 2.10: */
fr: || /* Depuis la glibc 2.10 : */

note: type: Plain text
en: The function B<dirfd>()  returns the file descriptor associated with the directory stream I<dirp>.
fr: La fonction B<dirfd>() renvoie le descripteur de fichier associé au flux du répertoire I<dirp>.

note: type: Plain text
en: This descriptor is the one used internally by the directory stream.  As a result, it is useful only for functions which do not depend on or alter the file position, such as B<fstat>(2)  and B<fchdir>(2).  It will be automatically closed when B<closedir>(3)  is called.
fr: Ce descripteur est celui qui utilisé en interne par le flux du répertoire. Il est donc seulement utile pour les fonctions qui ne dépendent pas ou n'altèrent pas la position du fichier, comme B<fstat>(2) et B<fchdir>(2). Il est automatiquement fermé lorsque B<closedir>(3) est appelée.

note: type: Plain text
en: On success, a nonnegative file descriptor is returned.  On error, -1 is returned, and I<errno> is set to indicate the cause of the error.
fr: Si elle réussit, cette fonction renvoie un descripteur de fichier non négatif. En cas d'erreur, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: glibc 2.8 type: Plain text
en: POSIX.1-2008 specifies two errors, neither of which is returned by the current implementation.
fr: POSIX.1.2008 définit deux erreurs, aucune d'elles n'est retournée par l'implémentation actuelle.

note: type: Plain text
en: I<dirp> does not refer to a valid directory stream.
fr: I<dirp> ne fait pas référence à un flux répertoire valable.

note: type: Plain text
en: The implementation does not support the association of a file descriptor with a directory.
fr: L'implémentation ne gère pas l'association d'un descripteur de fichier avec un répertoire.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<dirfd>()  function is thread-safe.
fr: La fonction B<dirfd>() est sûre dans un contexte multithread.

note: It is present in libc5 (since 5.1.2) and in glibc2. type: Plain text
en: POSIX.1-2008.  This function was a BSD extension, present in 4.3BSD-Reno, not in 4.2BSD.
fr: POSIX.1.2008. Cette fonction est une extension BSD\ ; présente dans 4.3BSD.Reno, non présente dans 4.2BSD.

note: type: Plain text
en: The prototype for B<dirfd>()  is available only if B<_BSD_SOURCE> or B<_SVID_SOURCE> is defined.
fr: Le prototype de B<dirfd>() n'est disponible que si B<_BSD_SOURCE> ou B<_SVID_SOURCE> est définie.

note: type: TH
en: 2012-08-03
fr: 3 août 2012

note: type: Plain text
en: getdents - get directory entries
fr: getdents - Obtenir les points d'entrée d'un répertoire

note: type: Plain text
en: I<Note>: There is no glibc wrapper for this system call; see NOTES.
fr: I<Remarque> : il n'existe pas de fonction glibc autour de cet appel système ; consultez B<NOTES>.

note: type: Plain text
en: This is not the function you are interested in.  Look at B<readdir>(3)  for the POSIX conforming C library interface.  This page documents the bare kernel system call interface.
fr: Ce n'est pas la fonction qui vous intéresse. Veuillez regarder B<readdir>(3) pour l'interface de la fonction de même nom de la bibliothèque C conforme à la spécification POSIX. Cette page documente l'interface de l'appel système du noyau.

note: type: Plain text
en: The system call B<getdents>()  reads several I<linux_dirent> structures from the directory referred to by the open file descriptor I<fd> into the buffer pointed to by I<dirp>.  The argument I<count> specifies the size of that buffer.
fr: L'appel système B<getdents>() lit plusieurs structures I<linux_dirent> depuis le répertoire référencé par le descripteur de fichier ouvert I<fd> et les place dans la zone de mémoire pointée par I<dirp>. Le paramètre I<count> spécifie la taille de cette zone mémoire.

note: type: Plain text
en: The I<linux_dirent> structure is declared as follows:
fr: La structure I<linux_dirent> est déclarée comme ceci\ :

note: type: Plain text
en: struct linux_dirent {
        unsigned long  d_ino;     /* Inode number */
        unsigned long  d_off;     /* Offset to next I<linux_dirent> */
        unsigned short d_reclen;  /* Length of this I<linux_dirent> */
        char           d_name[];  /* Filename (null-terminated) */
                          /* length is actually (d_reclen - 2 -
                             offsetof(struct linux_dirent, d_name)) */
        /*
        char           pad;       // Zero padding byte
        char           d_type;    // File type (only since Linux
                                  // 2.6.4); offset is (d_reclen - 1)
        */
fr: struct linux_dirent {
        unsigned long  d_ino;     /* Numéro d'inœud */
        unsigned long  d_off;     /* Distance au prochain I<linux_dirent> */
        unsigned short d_reclen;  /* Longueur de ce I<linux_dirent> */
        char           d_name[];  /* Nom de fichier (fini par 0) */
                            /* La longueur est en fait (d_reclen - 2 -
                               offsetof(struct linux_dirent, d_name)) */
        /*
        char           pad;       // Octet nul de remplissage
        char           d_type;    // Type de fichier (seulement depuis
                                  // Linux 2.6.4) ; sa position est
                                  // (d_reclen - 1)
        */

note: type: Plain text
en: I<d_ino> is an inode number.  I<d_off> is the distance from the start of the directory to the start of the next I<linux_dirent>.  I<d_reclen> is the size of this entire I<linux_dirent>.  I<d_name> is a null-terminated filename.
fr: I<d_ino> est un numéro d'inœud. I<d_off> est la distance entre le début du répertoire et le début de la prochaine structure I<linux_dirent>. I<d_reclen> est la taille complète de I<linux_dirent>. I<d_name> est le nom de fichier terminé par un caractère nul.

note: type: Plain text
en: I<d_type> is a byte at the end of the structure that indicates the file type.  It contains one of the following values (defined in I<E<lt>dirent.hE<gt>>):
fr: I<d_type> est un octet placé à la fin de la structure qui indique le type du fichier. Il contient l'une des valeurs suivantes (définies dans I<E<lt>dirent.hE<gt>>) :

note: type: Plain text
en: This is a block device.
fr: Il s'agit d'un périphérique bloc.

note: type: Plain text
en: This is a character device.
fr: Il s'agit d'un périphérique caractère.

note: type: Plain text
en: This is a directory.
fr: Il s'agit d'un répertoire

note: type: Plain text
en: This is a named pipe (FIFO).
fr: Il s'agit d'un tube nommé (FIFO).

note: type: Plain text
en: This is a symbolic link.
fr: Il s'agit d'un lien symbolique.

note: type: Plain text
en: This is a regular file.
fr: Il s'agit d'un fichier ordinaire.

note: type: Plain text
en: This is a UNIX domain socket.
fr: Il s'agit d'une socket de domaine UNIX.

note: The glibc manual says that on some systems this is the only value returned type: Plain text
en: The file type is unknown.
fr: Le type du fichier est inconnu.

note: type: Plain text
en: The I<d_type> field is implemented since Linux 2.6.4.  It occupies a space that was previously a zero-filled padding byte in the I<linux_dirent> structure.  Thus, on kernels before 2.6.3, attempting to access this field always provides the value 0 (B<DT_UNKNOWN>).
fr: Le champ I<d_type> est implémenté depuis Linux 2.6.4. Il occupe un espace qui était auparavant un octet de remplissage rempli par des zéros dans la structure I<linux_dirent>. Ainsi, sur les noyaux antérieurs à 2.6.3, les accès à ce champ fournissent toujours la valeur 0 (B<DT_UNKNOWN>).

note: kernel 2.6.27 The same sentence is in getdents.2 type: Plain text
en: Currently, only some filesystems (among them: Btrfs, ext2, ext3, and ext4)  have full support for returning the file type in I<d_type>.  All applications must properly handle a return of B<DT_UNKNOWN>.
fr: Actuellement, seuls certains systèmes de fichiers (parmi lesquels Btrfs, ext2, ext3 et ext4) prennent complètement en charge le renvoi du type de fichier dans I<d_type>. Toutes les applications doivent gérer correctement une valeur de retour valant B<DT_UNKNOWN>.

note: type: Plain text
en: On success, the number of bytes read is returned.  On end of directory, 0 is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<getdents> renvoie le nombre d'octets lus s'il réussit (0 en fin de répertoire), ou -1 s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: Invalid file descriptor I<fd>.
fr: I<fd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: Argument points outside the calling process's address space.
fr: L'argument pointe en dehors de l'espace d'adressage du processus appelant.

note: type: Plain text
en: Result buffer is too small.
fr: Le tampon de résultat est trop petit.

note: type: Plain text
en: No such directory.
fr: Répertoire inexistant.

note: type: Plain text
en: File descriptor does not refer to a directory.
fr: Le descripteur de fichier ne pointe pas sur un répertoire.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).  You will need to define the I<linux_dirent> structure yourself.  However, you probably want to use B<readdir>(3)  instead.
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; vous devez utiliser B<syscall>(2) pour l'appeler. Vous devrez définir la structure I<linux_dirent> vous-même. Cependant, B<readdir>(3) peut avantageusement être utilisé à la place.

note: type: Plain text
en: This call supersedes B<readdir>(2).
fr: Cette fonction remplace B<readdir>(2).

note: type: Plain text
en: The original Linux B<getdents>()  system call did not handle large filesystems and large file offsets.  Consequently, Linux 2.4 added B<getdents64>(), with wider types for the I<d_ino> and I<d_off> fields employed in the I<linux_dirent> structure.
fr: L'appel système B<getdents>() original de Linux ne permettait pas de gérer les gros fichiers et les positions dans les gros fichiers. En conséquence, Linux 2.4 a ajouté B<getdents64>(), avec un type élargi pour les champs I<d_ino> et I<d_off> de la structure I<linux_dirent>.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: FIXME: This program uses the older getdents() system call and the structure with smaller field widths. type: Plain text
en: The program below demonstrates the use of B<getdents>().  The following output shows an example of what we see when running this program on an ext2 directory:
fr: Le programme ci-dessous démontre l'utilisation de B<getdents>(). La sortie suivante montre un exemple de ce que donne le programme sur une répertoire ext2 :

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: #define _GNU_SOURCE
    #include E<lt>dirent.hE<gt>     /* Defines DT_* constants */
    #include E<lt>fcntl.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/stat.hE<gt>
    #include E<lt>sys/syscall.hE<gt>
fr: #define _GNU_SOURCE
    #include E<lt>dirent.hE<gt>     /* Définie les constantes DT_* */
    #include E<lt>fcntl.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>unistd.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/stat.hE<gt>
    #include E<lt>sys/syscall.hE<gt>

note: type: TH
en: 2007-07-26
fr: 26 juillet 2007

note: type: Plain text
en: getdirentries - get directory entries in a filesystem-independent format
fr: getdirentries - Lire le contenu d'un répertoire dans un format indépendant du système

note: type: Plain text
en: B<getdirentries>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<getdirentries>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: Read directory entries from the directory specified by I<fd> into I<buf>.  At most I<nbytes> are read.  Reading starts at offset I<*basep>, and I<*basep> is updated with the new position after reading.
fr: La fonction B<getdirentries>() lit les entrées d'un répertoire indiqué par I<fd> dans le tampon I<buf>. I<nbytes> octets au maximum sont lus. La lecture démarre à la position I<*basep>, puis I<*basep> est mis à jour avec la nouvelle position à lire.

note: type: Plain text
en: B<getdirentries>()  returns the number of bytes read or zero when at the end of the directory.  If an error occurs, -1 is returned, and I<errno> is set appropriately.
fr: B<getdirentries>() renvoie le nombre d'octets lus, ou 0 à la fin du répertoire. En cas d'échec, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: See the Linux library source code for details.
fr: Consultez le code source de la bibliothèque Linux pour obtenir des détails.

note: type: Plain text
en: Not in POSIX.1-2001.  Present on the BSDs, and a few other systems.  Use B<opendir>(3)  and B<readdir>(3)  instead.
fr: Absent de POSIX.1-2001. Présent dans BSD et quelques autres systèmes. Utilisez à la place B<opendir>(3) et B<readdir>(3).

note: type: TH
en: 2010-06-20
fr: 20 juin 2010

note: type: Plain text
en: opendir, fdopendir - open a directory
fr: opendir, fdopendir - Ouvrir un répertoire

note: type: Plain text
en: B<DIR *opendir(const char *>I<name>B<);>
    B<DIR *fdopendir(int >I<fd>B<);>
fr: B<DIR *opendir(const char *>I<nom>B<);>
    B<DIR *fdopendir(int >I<fd>B<);>

note: type: TP
en: Since glibc 2.10:
fr: Depuis la glibc 2.10 :

note: type: TP
en: Before glibc 2.10:
fr: Avant la glibc 2.10 :

note: type: Plain text
en: The B<opendir>()  function opens a directory stream corresponding to the directory I<name>, and returns a pointer to the directory stream.  The stream is positioned at the first entry in the directory.
fr: La fonction B<opendir>() ouvre un flux répertoire correspondant au répertoire I<nom>, et renvoie un pointeur sur ce flux. Le flux est positionné sur la première entrée du répertoire.

note: type: Plain text
en: The B<fdopendir>()  function is like B<opendir>(), but returns a directory stream for the directory referred to by the open file descriptor I<fd>.  After a successful call to B<fdopendir>(), I<fd> is used internally by the implementation, and should not otherwise be used by the application.
fr: La fonction B<fdopendir>() est similaire à B<opendir>(), mais renvoie un flux de répertoire pour le répertoire demandé avec le descripteur de fichier I<fd> ouvert. Après un appel réussi à B<fdopendir>(), I<fd> est utilisé en interne par l'implémentation, et ne doit plus être utilisé par l'application.

note: type: Plain text
en: The B<opendir>()  and B<fdopendir>()  functions return a pointer to the directory stream.  On error, NULL is returned, and I<errno> is set appropriately.
fr: Les fonctions B<opendir>() et B<fdopendir>() renvoient un pointeur sur le flux répertoire. Si une erreur se produit, NULL est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: Permission denied.
fr: Accès interdit.

note: type: Plain text
en: I<fd> is not a valid file descriptor opened for reading.
fr: I<fd> n'est pas un descripteur de fichier valable ouvert en lecture.

note: type: Plain text
en: Too many file descriptors in use by process.
fr: Trop de descripteurs de fichier pour le processus en cours.

note: type: Plain text
en: Too many files are currently open in the system.
fr: Trop de fichiers ouverts simultanément sur le système.

note: type: Plain text
en: Directory does not exist, or I<name> is an empty string.
fr: Le répertoire n'existe pas, ou I<nom> est une chaîne vide.

note: type: Plain text
en: Insufficient memory to complete the operation.
fr: Pas assez de mémoire pour terminer l'opération.

note: type: Plain text
en: I<name> is not a directory.
fr: I<nom> n'est pas un répertoire

note: type: Plain text
en: B<fdopendir>()  is available in glibc since version 2.4.
fr: B<fdopendir>() est disponible dans la glibc depuis la version 2.4.

note: type: Plain text
en: B<opendir>()  is present on SVr4, 4.3BSD, and specified in POSIX.1-2001.  B<fdopendir>()  is specified in POSIX.1-2008.
fr: B<opendir>() est présente dans SVr4, BSD 4.3 et spécifiée dans POSIX.1-2001. B<fdopendir>() est spécifiée dans POSIX.1-2008.

note: type: Plain text
en: The underlying file descriptor of the directory stream can be obtained using B<dirfd>(3).
fr: Le descripteur sous-jacent à un flux répertoire peut être obtenu avec B<dirfd>(3).

note: type: Plain text
en: The B<opendir>()  function sets the close-on-exec flag for the file descriptor underlying the I<DIR *>.  The B<fdopendir>()  function leaves the setting of the close-on-exec flag unchanged for the file descriptor, I<fd>.  POSIX.1-200x leaves it unspecified whether a successful call to B<fdopendir>()  will set the close-on-exec flag for the file descriptor, I<fd>.
fr: La fonction B<opendir>() définit l'attribut « close-on-exec » pour le descripteur de fichier sous-jacent à I<DIR *>. La fonction B<fdopendir>() laisse inchangée la configuration de l'attribut « close-on-exec » pour le descripteur de fichier I<fd>. POSIX.1-200x laisse ouvert la le fait que l'attribut close-on-exec du descripteur de fichier I<fd> soit positionné ou non par un appel réussi à B<fdopendir>().

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: readdir - read directory entry
fr: readdir - Lire une entrée de répertoire

note: type: Plain text
en: This is not the function you are interested in.  Look at B<readdir>(3)  for the POSIX conforming C library interface.  This page documents the bare kernel system call interface, which is superseded by B<getdents>(2).
fr: Cette fonction n'est normalement pas intéressante pour les programmeurs. Utiliser B<readdir>(3) pour les fonctionnalités conformes POSIX. Cette page documente l'interface de l'appel système bas niveau, qui est remplacée par B<getdents>(2).

note: type: Plain text
en: B<readdir>()  reads one I<old_linux_dirent> structure from the directory referred to by the file descriptor I<fd> into the buffer pointed to by I<dirp>.  The argument I<count> is ignored; at most one I<old_linux_dirent> structure is read.
fr: B<readdir>() lit une structure I<old_linux_dirent> depuis le répertoire référencé par le descripteur de fichier I<fd> et la place dans le tampon pointé par I<dirp>. Le paramètre I<count> est ignoré, au plus une structure I<old_linux_dirent> est lue.

note: type: Plain text
en: The I<old_linux_dirent> structure is declared as follows:
fr: La structure I<old_linux_dirent> est déclarée comme ceci\ :

note: type: Plain text
en: struct old_linux_dirent {
        long  d_ino;              /* inode number */
        off_t d_off;              /* offset to this I<old_linux_dirent> */
        unsigned short d_reclen;  /* length of this I<d_name> */
        char  d_name[NAME_MAX+1]; /* filename (null-terminated) */
    }
fr: struct dirent {
        long  d_ino;              /* numéro d'inœud */
        off_t d_off;              /* position de ce I<old_linux_dirent> */
        unsigned short d_reclen;  /* longueur de I<d_name> */
        char  d_name[NAME_MAX+1]; /* nom du fichier (terminé par \(rs0) */
    }

note: type: Plain text
en: I<d_ino> is an inode number.  I<d_off> is the distance from the start of the directory to this I<old_linux_dirent>.  I<d_reclen> is the size of I<d_name>, not counting the terminating null byte (\(aq\e0\(aq).  I<d_name> is a null-terminated filename.
fr: I<d_ino> est un numéro d'inœud. I<d_off> est la distance entre le début du répertoire et cette structure I<old_linux_dirent>. I<d_reclen> est la longueur de I<d_name>, sans compter l'octet nul final (« \e0 »). I<d_name> est le nom de fichier terminé par un caractère nul.

note: type: Plain text
en: On success, 1 is returned.  On end of directory, 0 is returned.  On error, -1 is returned, and I<errno> is set appropriately.
fr: B<readdir> renvoie 1 s'il réussit, 0 en fin de répertoire, ou -1 s'il échoue, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: This system call is Linux-specific.
fr: Cet appel système est spécifique à Linux.

note: type: Plain text
en: Glibc does not provide a wrapper for this system call; call it using B<syscall>(2).  You will need to define the I<old_linux_dirent> structure yourself.  However, probably you should use B<readdir>(3)  instead.
fr: La glibc ne fournit pas de fonction autour de cet appel système\ ; utilisez B<syscall>(2) pour l'appeler. Vous devrez définir la structure I<old_linux_dirent> vous-même. Cependant, B<readdir>(3) peut avantageusement être utilisé à la place.

note: type: Plain text
en: This system call does not exist on x86-64.
fr: Cet appel système n'existe pas sur x86-64.

note: type: Plain text
en: readdir, readdir_r - read a directory
fr: readdir, readdir_r - Consulter un répertoire

note: type: Plain text
en: B<readdir_r>():
fr: B<readdir_r>() :

note: type: Plain text
en: The B<readdir>()  function returns a pointer to a I<dirent> structure representing the next directory entry in the directory stream pointed to by I<dirp>.  It returns NULL on reaching the end of the directory stream or if an error occurred.
fr: La fonction B<readdir>() renvoie un pointeur sur une structure I<dirent> représentant l'entrée suivante du flux répertoire pointé par I<dirp>. Elle renvoie NULL a la fin du répertoire, ou en cas d'erreur.

note: type: Plain text
en: On Linux, the I<dirent> structure is defined as follows:
fr: Avec Linux, la structure I<dirent> est définie comme suit\ :

note: type: Plain text
en: struct dirent {
        ino_t          d_ino;       /* inode number */
        off_t          d_off;       /* not an offset; see NOTES */
        unsigned short d_reclen;    /* length of this record */
        unsigned char  d_type;      /* type of file; not supported
                                       by all filesystem types */
        char           d_name[256]; /* filename */
    };
fr: struct dirent {
        ino_t          d_ino;       /* numéro d'inœud */
        off_t          d_off;       /* pas une position ; consultez NOTES */
        unsigned short d_reclen;    /* longueur de cet enregistrement */
        unsigned char  d_type;      /* type du fichier ; pas pris en
                                       charge par tous les types de
                                       système de fichiers */
        char           d_name[256]; /* nom du fichier */
    };

note: type: Plain text
en: The only fields in the I<dirent> structure that are mandated by POSIX.1 are: I<d_name>[], of unspecified size, with at most B<NAME_MAX> characters preceding the terminating null byte (\(aq\e0\(aq); and (as an XSI extension)  I<d_ino>.  The other fields are unstandardized, and not present on all systems; see NOTES below for some further details.
fr: Les seuls champs exigés par POSIX.1 pour la structure I<dirent> sont : I<d_name>[], de taille non définie, avec au plus B<NAME_MAX> caractères avant le caractère nul final (« \e0 ») ; et (en tant qu'extension XSI) I<d_ino>. Les autres champs ne sont pas standard, et ne sont pas présents sur tous les systèmes ; consultez les B<NOTES> ci-dessous pour plus de détails.

note: type: Plain text
en: The data returned by B<readdir>()  may be overwritten by subsequent calls to B<readdir>()  for the same directory stream.
fr: Les données renvoyées par B<readdir>() sont écrasées lors de l'appel suivant à B<readdir>() sur le même flux répertoire.

note: type: Plain text
en: The B<readdir_r>()  function is a reentrant version of B<readdir>().  It reads the next directory entry from the directory stream I<dirp>, and returns it in the caller-allocated buffer pointed to by I<entry>.  (See NOTES for information on allocating this buffer.)  A pointer to the returned item is placed in I<*result>; if the end of the directory stream was encountered, then NULL is instead returned in I<*result>.
fr: La fonction B<readdir_r>() est la version réentrante de B<readdir>(). Elle lit la prochaine entrée de répertoire à partir du flux de répertoire I<dirp>, et la renvoie dans le tampon de l'appelant pointé par I<entry>. (Consultez la section NOTES pour des informations sur l'allocation de ce tampon.) Un pointeur vers l'élément renvoyé est placé dans I<*result> ; si la fin du flux de répertoire est rencontrée, NULL est renvoyé dans I<*result>.

note: type: Plain text
en: On success, B<readdir>()  returns a pointer to a I<dirent> structure.  (This structure may be statically allocated; do not attempt to B<free>(3)  it.)  If the end of the directory stream is reached, NULL is returned and I<errno> is not changed.  If an error occurs, NULL is returned and I<errno> is set appropriately.
fr: En cas de succès, B<readdir>() renvoie un pointeur sur une structure I<dirent> (cette structure peut avoir été allouée statiquement ; n'essayez pas de la désallouer avec B<free>(3)). Lorsque la fin du flux répertoire est atteinte, NULL est renvoyé et I<errno> n'est pas modifiée. En cas d'erreur, NULL est renvoyée et I<errno> contient le code d'erreur.

note: type: Plain text
en: The B<readdir_r>()  function returns 0 on success.  On error, it returns a positive error number (listed under ERRORS).  If the end of the directory stream is reached, B<readdir_r>()  returns 0, and returns NULL in I<*result>.
fr: La fonction B<readdir_r>() renvoie 0 si elle réussit. Si elle échoue, elle renvoie un code d'erreur positif (documenté dans B<ERREURS>). Si la fin du flux répertoire est atteinte, B<readdir_r>() renvoie 0 et renvoie NULL dans I<*result>.

note: type: Plain text
en: The B<readdir>()  function is not thread-safe.
fr: La fonction B<readdir>() n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: The B<readdir_r>()  function is thread-safe.
fr: La fonction B<readdir_r>() est sûre dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: Only the fields I<d_name> and I<d_ino> are specified in POSIX.1-2001.  The remaining fields are available on many, but not all systems.  Under glibc, programs can check for the availability of the fields not defined in POSIX.1 by testing whether the macros B<_DIRENT_HAVE_D_NAMLEN>, B<_DIRENT_HAVE_D_RECLEN>, B<_DIRENT_HAVE_D_OFF>, or B<_DIRENT_HAVE_D_TYPE> are defined.
fr: Seuls les champs I<d_name> et I<d_ino> sont spécifiés dans POSIX.1-2001. les autres champs sont disponibles sur beaucoup de systèmes, mais pas sur tous. Sur la glibc, les programmes peuvent vérifier la disponibilités des champs non définis dans POSIX.1 en testant sir les macros B<_DIRENT_HAVE_D_NAMLEN>, B<_DIRENT_HAVE_D_RECLEN>, B<_DIRENT_HAVE_D_OFF> ou B<_DIRENT_HAVE_D_TYPE> sont définie.

note: https://lwn.net/Articles/544298/ type: Plain text
en: The value returned in I<d_off> is the same as would be returned by calling B<telldir>(3)  at the current position in the directory stream.  Be aware that despite its type and name, the I<d_off> field is seldom any kind of directory offset on modern filesystems.  Applications should treat this field as an opaque value, making no assumptions about its contents; see also B<telldir>(3).
fr: La valeur renvoyée dans I<d_off> est la même qui serait renvoyée en appelant B<telldir>(3) à la position actuelle dans le flux répertoire. Soyez conscient que, malgré ses type et nom, le champ I<d_off> ne représente que rarement une sorte de position de répertoire sur les systèmes de fichiers modernes. Les applications devraient traiter ce champ comme une valeur opaque, sans faire de supposition sur son contenu. Consultez aussi B<telldir>(3).

note: type: Plain text
en: Other than Linux, the I<d_type> field is available mainly only on BSD systems.  This field makes it possible to avoid the expense of calling B<lstat>(2)  if further actions depend on the type of the file.  If the B<_BSD_SOURCE> feature test macro is defined, then glibc defines the following macro constants for the value returned in I<d_type>:
fr: En dehors de Linux, le champ I<d_type> est disponible presque uniquement sur les systèmes BSD. Ce champ évite d'avoir à appeler B<lstat>(2) si les actions qui suivent dépendent du type de fichier. Si la macro de test de fonctionnalités B<_BSD_SOURCE> est définie, alors la glibc définie les macros suivantes pour les valeurs renvoyées dans I<d_type> :

note: type: Plain text
en: If the file type could not be determined, the value B<DT_UNKNOWN> is returned in I<d_type>.
fr: Si le type de fichier ne peut pas être déterminé, la valeur B<DT_UNKNOWN> est renvoyée dans I<d_type>.

note: type: Plain text
en: Since POSIX.1 does not specify the size of the I<d_name> field, and other nonstandard fields may precede that field within the I<dirent> structure, portable applications that use B<readdir_r>()  should allocate the buffer whose address is passed in I<entry> as follows:
fr: Puisque POSIX.1 ne spécifie pas la taille du champ I<d_name>, et que d'autres champs non standard peuvent précéder ce champ dans la structure I<dirent>, les applications portables utilisant B<readdir_r>() devraient allouer le tampon dont l'adresse est passée dans I<entry> de la façon suivante :

note: type: Plain text
en: name_max = pathconf(dirpath, _PC_NAME_MAX);
    if (name_max == -1)         /* Limit not defined, or error */
        name_max = 255;         /* Take a guess */
    len = offsetof(struct dirent, d_name) + name_max + 1;
    entryp = malloc(len);
fr: name_max = pathconf(dirpath, _PC_NAME_MAX);
    if (name_max == -1)         /* Limite non définie ou erreur */
        name_max = 255;         /* Au hasard */
    len = offsetof(struct dirent, d_name) + name_max + 1;
    entryp = malloc(len);

note: type: Plain text
en: (POSIX.1 requires that I<d_name> is the last field in a I<struct dirent>.)
fr: (POSIX.1 demande que I<d_name> soit le dernier champ d'une structure I<dirent>.)

note: type: TH
en: 2013-09-02
fr: 2 septembre 2013

note: type: Plain text
en: rewinddir - reset directory stream
fr: rewinddir - Réinitialiser un flux répertoire

note: type: Plain text
en: The B<rewinddir>()  function resets the position of the directory stream I<dirp> to the beginning of the directory.
fr: La fonction B<rewinddir>() réinitialise la position du pointeur du flux I<dirp> au début du répertoire.

note: type: Plain text
en: The B<rewinddir>()  function returns no value.
fr: La fonction B<rewinddir>() ne renvoie pas de valeur.

note: type: Plain text
en: The B<rewinddir>()  function is thread-safe.
fr: La fonction B<rewinddir>() est sûre dans un contexte multithread.

note: type: TH
en: 2014-02-21
fr: 21 février 2014

note: type: Plain text
en: scandir, scandirat, alphasort, versionsort - scan a directory for matching entries
fr: scandir, scandirat, alphasort, versionsort - Sélectionner des éléments d'un répertoire

note: type: Plain text
en: B<#include E<lt>fcntl.hE<gt>>          /* Definition of AT_* constants */
    B<#include E<lt>dirent.hE<gt>>
fr: B<#include E<lt>fcntl.hE<gt>>          /* Définition des constantes AT_* */
    B<#include E<lt>dirent.hE<gt>>

note: type: Plain text
en: B<scandir>(), B<alphasort>():
fr: B<scandir>(), B<alphasort>() :

note: type: Plain text
en: B<versionsort>(): _GNU_SOURCE
fr: B<versionsort>() : _GNU_SOURCE

note: type: Plain text
en: B<scandirat>(): _GNU_SOURCE
fr: B<scandirat>() : _GNU_SOURCE

note: type: Plain text
en: The B<scandir>()  function scans the directory I<dirp>, calling I<filter>() on each directory entry.  Entries for which I<filter>() returns nonzero are stored in strings allocated via B<malloc>(3), sorted using B<qsort>(3)  with the comparison function I<compar>(), and collected in array I<namelist> which is allocated via B<malloc>(3).  If I<filter> is NULL, all entries are selected.
fr: La fonction B<scandir>() examine le répertoire I<dirp>, en appelant I<filter>() pour chaque élément rencontré. Les entrées pour lesquelles I<filter>() renvoie une valeur non nulle sont stockées dans une table allouée avec B<malloc>(3), triée avec B<qsort>(3) en utilisant la fonction de comparaison I<compar>(), puis regroupées dans une table I<namelist> allouée avec B<malloc>(3). Si I<filter> est NULL, toutes les entrées sont sélectionnées.

note: type: Plain text
en: The B<alphasort>()  and B<versionsort>()  functions can be used as the comparison function I<compar>().  The former sorts directory entries using B<strcoll>(3), the latter using B<strverscmp>(3)  on the strings I<(*a)-E<gt>d_name> and I<(*b)-E<gt>d_name>.
fr: Les fonctions B<alphasort>() et B<versionsort>() peuvent être utilisées comme fonction de comparaison I<compar>. La première trie les entrées du répertoire en ordre alphabétique en utilisant B<strcoll>(3), la seconde en utilisant B<strverscmp>(3) sur les chaînes I<(*a)-E<gt>d_name> et I<(*b)-E<gt>d_name>.

note: type: Plain text
en: The B<scandirat>()  function operates in exactly the same way as B<scandir>(), except for the differences described here.
fr: La fonction B<scandirat>() fonctionne exactement comme B<scandir>(3), les seules différences étant décrites ici.

note: type: Plain text
en: If the pathname given in I<dirp> is relative, then it is interpreted relative to the directory referred to by the file descriptor I<dirfd> (rather than relative to the current working directory of the calling process, as is done by B<scandir>()  for a relative pathname).
fr: Si le nom de chemin donné dans I<dirp> est relatif, il est considéré relatif au répertoire référencé par le descripteur de fichier I<dirfd> (plutôt que relatif au répertoire de travail actuel du processus appelant, comme avec B<scandir>() pour un nom de chemin relatif).

note: type: Plain text
en: If I<dirp> is relative and I<dirfd> is the special value B<AT_FDCWD>, then I<dirp> is interpreted relative to the current working directory of the calling process (like B<scandir>()).
fr: Si I<dirp> est relatif et que I<dirfd> est la valeur particulière B<AT_FDCWD>, alors I<dirp> est considéré relatif au répertoire de travail actuel du processus appelant (comme B<scandir>()).

note: type: Plain text
en: If I<dirp> is absolute, then I<dirfd> is ignored.
fr: Si I<dirp> est absolu, alors I<dirfd> est ignoré.

note: type: Plain text
en: See B<openat>(2)  for an explanation of the need for B<scandirat>().
fr: Consultez B<openat>(2) pour une explication sur la nécessité de B<scandirat>().

note: type: Plain text
en: The B<scandir>()  function returns the number of directory entries selected.  On error, -1 is returned, with I<errno> set to indicate the cause of the error.
fr: La fonction B<scandir>() renvoie le nombre d'entrées de répertoires sélectionnées s'il réussit, ou -1 s'il échoue, avec I<errno> qui contient le code d'erreur.

note: type: Plain text
en: The B<alphasort>()  and B<versionsort>()  functions return an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
fr: Les fonctions B<alphasort>() et B<versionsort>() renvoient un entier négatif, nul, ou positif si le premier argument est respectivement inférieur, égal ou supérieur au second.

note: type: Plain text
en: The path in I<dirp> does not exist.
fr: Le chemin n'existe pas dans I<dirp>.

note: type: Plain text
en: The path in I<dirp> is not a directory.
fr: Le chemin n'est pas un répertoire de I<dirp>.

note: type: Plain text
en: The following additional errors can occur for B<scandirat>():
fr: Les erreurs supplémentaires suivantes peuvent se produire avec B<scandirat>().

note: type: Plain text
en: I<dirfd> is not a valid file descriptor.
fr: I<dirfd> n'est pas un descripteur de fichier valable.

note: type: Plain text
en: I<dirp> is a relative path and I<dirfd> is a file descriptor referring to a file other than a directory.
fr: I<dirp> est un chemin relatif et I<dirfd> est un descripteur de fichier référençant un fichier qui n'est pas un répertoire.

note: type: Plain text
en: B<versionsort>()  was added to glibc in version 2.1.
fr: B<versionsort>() a été ajoutée à la glibc dans la version 2.1.

note: type: Plain text
en: B<scandirat>()  was added to glibc in version 2.15.
fr: B<scandirat>() a été ajoutée à la glibc dans la version 2.15.

note: type: Plain text
en: B<alphasort>(), B<scandir>(): 4.3BSD, POSIX.1-2008.
fr: B<alphasort>(), B<scandir>() : BSD 4.3, POSIX.1-2008.

note: .LP The functions .BR scandir () and .BR alphasort () are from 4.3BSD, and have been available under Linux since libc4. Libc4 and libc5 use the more precise prototype .sp .nf int alphasort(const struct dirent ** a, const struct dirent **b); .fi but glibc 2.0 returns to the imprecise BSD prototype. t
en: B<versionsort>()  and B<scandirat>()  are GNU extensions.
fr: B<versionsort>() et B<scandirat>() sont des extensions GNU.

note: type: Plain text
en: Since glibc 2.1, B<alphasort>()  calls B<strcoll>(3); earlier it used B<strcmp>(3).
fr: Depuis la glibc 2.1, la fonction B<alphasort>() invoque B<strcoll>(3). Dans les versions précédentes, elle appelait B<strcmp>(3).

note: type: Plain text
en: #define _SVID_SOURCE
    /* print files in current directory in reverse order */
    #include E<lt>dirent.hE<gt>
fr: #define _SVID_SOURCE
    /* Afficher le contenu du répertoire en ordre inverse */
    #include E<lt>dirent.hE<gt>

note: type: Plain text
en:     n = scandir(".", &namelist, NULL, alphasort);
        if (n E<lt> 0)
            perror("scandir");
        else {
            while (n--) {
                printf("%s\en", namelist[n]-E<gt>d_name);
                free(namelist[n]);
            }
            free(namelist);
        }
    }
fr:     n = scandir(".", &namelist, NULL, alphasort);
        if (n E<lt> 0)
            perror("scandir");
        else {
            while (n--) {
                printf("%s\en", namelist[n]-E<gt>d_name);
                free (namelist [n]);
            }
            free (namelist);
        }
    }

note: type: TH
en: 2013-09-09
fr: 9 septembre 2013

note: type: Plain text
en: seekdir - set the position of the next readdir() call in the directory stream.
fr: seekdir - Positionner le pointeur de flux répertoire pour le prochain appel readdir()

note: type: Plain text
en: B<seekdir>(): _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE
fr: B<seekdir>() : _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: The B<seekdir>()  function sets the location in the directory stream from which the next B<readdir>(2)  call will start.  The I<loc> argument should be a value returned by a previous call to B<telldir>(3).
fr: La fonction B<seekdir>() définit la position du pointeur de flux répertoire d'où le prochain appel B<readdir>(2) démarrera. L'argument I<loc> devrait être une valeur renvoyée par un appel précédent de B<telldir>(3).

note: type: Plain text
en: The B<seekdir>()  function returns no value.
fr: La fonction B<seekdir>() ne renvoie pas de valeur.

note: type: Plain text
en: The B<seekdir>()  function is thread-safe.
fr: La fonction B<seekdir>() est sûre dans un contexte multithread.

note: type: Plain text
en: 4.3BSD, POSIX.1-2001.
fr: BSD\ 4.3, POSIX.1-2001.

note: type: Plain text
en: In glibc up to version 2.1.1, the type of the I<loc> argument was I<off_t>.  POSIX.1-2001 specifies I<long>, and this is the type used since glibc 2.1.2.  See B<telldir>(3)  for information on why you should be careful in making any assumptions about the value in this argument.
fr: Dans la glibc jusqu'à la version 2.1.1, le type du paramètre I<loc> était I<off_t>. POSIX.1-2001 spécifie un I<long>, qui est aussi le type utilisé depuis la glibc 2.1.2. Consultez B<telldir>(3) pour des renseignements sur les raisons de devoir éviter de faire toutes supposition sur la valeur de cet argument.

note: type: Plain text
en: telldir - return current location in directory stream
fr: telldir - Obtenir la position actuelle dans un flux répertoire

note: type: Plain text
en: B<telldir>(): _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE
fr: B<telldir>() : _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: The B<telldir>()  function returns the current location associated with the directory stream I<dirp>.
fr: La fonction B<telldir>() renvoie la position actuelle du pointeur d'un flux répertoire I<dirp>.

note: type: Plain text
en: On success, the B<telldir>()  function returns the current location in the directory stream.  On error, -1 is returned, and I<errno> is set appropriately.
fr: La fonction B<telldir>() renvoie l'emplacement actuel dans le flux répertoire. En cas d'erreur, -1 est renvoyé, et I<errno> contient le code d'erreur.

note: type: Plain text
en: The B<telldir>()  function is thread-safe.
fr: La fonction B<telldir>() est sûre dans un contexte multithread.

note: type: Plain text
en: In glibc up to version 2.1.1, the return type of B<telldir>()  was I<off_t>.  POSIX.1-2001 specifies I<long>, and this is the type used since glibc 2.1.2.
fr: Dans la glibc avant la version 2.1.1, le type de retour de B<telldir>() était I<off_t>. POSIX.1-2001 spécifie un I<long>, ce qui est également le type utilisé depuis la glibc 2.1.2.

note: https://lwn.net/Articles/544298/ type: Plain text
en: In early filesystems, the value returned by B<telldir>()  was a simple file offset within a directory.  Modern filesystems use tree or hash structures, rather than flat tables, to represent directories.  On such filesystems, the value returned by B<telldir>()  (and used internally by B<readdir>(3))  is a "cookie" that is used by the implementation to derive a position within a directory.  Application programs should treat this strictly as an opaque value, making I<no> assumptions about its contents.
fr: Dans les premiers systèmes de fichiers, la valeur renvoyée par B<telldir>() était une simple position de fichier à l'intérieur d'un répertoire. Les systèmes de fichiers modernes utilisent des structures d'arbres ou de hachage, plutôt que des tableaux plats, pour représenter des répertoires. Sur ce genre de systèmes de fichiers, la valeur renvoyée par B<telldir>() (et utilisée en interne par B<readdir>(3)) est un « cookie » utilisé par l'implémentation pour dériver une position à l'intérieur d'un répertoire. Les programmes des applications devraient traiter cela strictement comme une valeur opaque, sans faire B<aucune> supposition sur son contenu.
