perkamon - en to fr translation catalogue (80 entries)

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

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: name_to_handle_at, open_by_handle_at - obtain handle for a pathname and open file via a handle
fr: name_to_handle_at, open_by_handle_at - récupérer le gestionnaire d'un chemin et le ouvrir le fichier au moyen d'un gestionnaire

note: type: Plain text
en: The B<name_to_handle_at>()  and B<open_by_handle_at>()  system calls split the functionality of B<openat>(2)  into two parts: B<name_to_handle_at>()  returns an opaque handle that corresponds to a specified file; B<open_by_handle_at>()  opens the file corresponding to a handle returned by a previous call to B<name_to_handle_at>()  and returns an open file descriptor.
fr: Les appels système B<name_to_handle_at>() et B<open_by_handle_at>() scindent la fonction de B<openat>(2) en deux parties : B<name_to_handle_at>() renvoie un gestionnaire opaque qui correspond à un fichier indiqué ; B<open_by_handle_at>() ouvre le fichier correspondant à un gestionnaire renvoyé par un appel antérieur à B<name_to_handle_at>() et renvoie le descripteur d'un fichier ouvert.

note: type: Plain text
en: The B<name_to_handle_at>()  system call returns a file handle and a mount ID corresponding to the file specified by the I<dirfd> and I<pathname> arguments.  The file handle is returned via the argument I<handle>, which is a pointer to a structure of the following form:
fr: L'appel système B<name_to_handle_at>() renvoie un gestionnaire de fichier et un identifiant de montage (« mount ID ») correspondant au fichier désigné par les arguments I<dirfd> et I<pathname>. Le gestionnaire de fichier est renvoyé au moyen de l'argument I<handle>. Cet argument est un pointeur vers une structure qui présente la forme suivante :

note: type: Plain text
en: struct file_handle {
        unsigned int  handle_bytes;   /* Size of f_handle [in, out] */
        int           handle_type;    /* Handle type [out] */
        unsigned char f_handle[0];    /* File identifier (sized by
                                         caller) [out] */
    };
fr: struct file_handle {
        unsigned int  handle_bytes;   /* taille de f_handle [in, out] */
        int           handle_type;    /* type du gestionnaire handle [out] */
        unsigned char f_handle[0];    /* identifiant du fichier (dont la taille est définie
                                         lors de l'appel) [out] */
    };

note: type: Plain text
en: Other than the use of the I<handle_bytes> field, the caller should treat the I<file_handle> structure as an opaque data type: the I<handle_type> and I<f_handle> fields are needed only by a subsequent call to B<open_by_handle_at>().
fr: Mise à part l'utilisation du champ I<handle_bytes>, l'appelant doit considérer la structure I<file_handle> comme une « boîte noire » : les champs I<handle_type> et I<f_handle> ne sont utiles que pour un appel ultérieur à B<open_by_handle_at>().

note: type: Plain text
en: The I<flags> argument is a bit mask constructed by ORing together zero or more of B<AT_EMPTY_PATH> and B<AT_SYMLINK_FOLLOW>, described below.
fr: L'argument I<flags> est un masque de bits construit par I<OU> binaire entre zéro ou plus de B<AT_EMPTY_PATH> et B<AT_SYMLINK_FOLLOW>, comme décrit plus bas.

note: type: Plain text
en: Together, the I<pathname> and I<dirfd> arguments identify the file for which a handle is to be obtained.  There are four distinct cases:
fr: Ensemble, les arguments I<pathname> et I<dirfd> désignent le fichier pour lequel on souhaite obtenir un gestionnaire. On distingue quatre cas :

note: type: Plain text
en: If I<pathname> is a nonempty string containing an absolute pathname, then a handle is returned for the file referred to by that pathname.  In this case, I<dirfd> is ignored.
fr: Si I<pathname> est une chaîne non vide contenant un chemin d'accès absolu, alors un gestionnaire est renvoyé pour le fichier indiqué par le chemin. Dans ce cas, I<dirfd> est ignoré.

note: type: Plain text
en: If I<pathname> is a nonempty string containing a relative pathname and I<dirfd> has the special value B<AT_FDCWD>, then I<pathname> is interpreted relative to the current working directory of the caller, and a handle is returned for the file to which it refers.
fr: Si I<pathname> est une chaîne non vide contenant un chemin relatif, et si I<dirfd> a la valeur spéciale B<AT_FDCWD>, alors I<pathname> est interprété par rapport au répertoire courant du processus appelant, et un gestionnaire est renvoyé pour le fichier indiqué par le chemin.

note: type: Plain text
en: If I<pathname> is an empty string and I<flags> specifies the value B<AT_EMPTY_PATH>, then I<dirfd> can be an open file descriptor referring to any type of file, or B<AT_FDCWD>, meaning the current working directory, and a handle is returned for the file to which it refers.
fr: Si I<pathname> est une chaîne vide, et si I<flags> précise la valeur de B<AT_EMPTY_PATH>, alors I<dirfd> peut être un descripteur de fichiers ouvert faisant référence à n'importe quel type de fichier ou à B<AT_FDCWD> (répertoire de travail courant), et un gestionnaire est renvoyé pour le fichier auquel il fait référence.

note: type: Plain text
en: By default, B<name_to_handle_at>()  does not dereference I<pathname> if it is a symbolic link, and thus returns a handle for the link itself.  If B<AT_SYMLINK_FOLLOW> is specified in I<flags>, I<pathname> is dereferenced if it is a symbolic link (so that the call returns a handle for the file referred to by the link).
fr: Par défaut, B<name_to_handle_at>() ne déréférence pas I<pathname> s'il s'agit d'un lien symbolique, et donc ne renvoie pas d'indicateur pour le lien symbolique. Si B<AT_SYMLINK_FOLLOW> est précisé dans I<flags>, I<pathname> est déréférencé s'il s'agit d'un lien symbolique (de sorte que l'appel renvoie un indicateur pour le fichier vers lequel pointe le lien symbolique).

note: type: Plain text
en: The B<open_by_handle_at>()  system call opens the file referred to by I<handle>, a file handle returned by a previous call to B<name_to_handle_at>().
fr: L'appel système B<open_by_handle_at>() ouvre le fichier auquel I<handle> fait référence, via un indicateur de fichier renvoyé lors d'un précédent appel à B<name_to_handle_at>().

note: type: Plain text
en: The I<mount_fd> argument is a file descriptor for any object (file, directory, etc.)  in the mounted filesystem with respect to which I<handle> should be interpreted.  The special value B<AT_FDCWD> can be specified, meaning the current working directory of the caller.
fr: L'argument I<mount_fd> est un descripteur de fichier pour n'importe quel type d'objet (fichier, répertoire, etc.) du système de fichiers monté qui permet d'interpréter l'indicateur de fichier (I<handle>). La valeur spéciale B<AT_FDCWD> peut être précisée, et indique le répertoire courant du processus appelant.

note: type: Plain text
en: The I<flags> argument is as for B<open>(2).  If I<handle> refers to a symbolic link, the caller must specify the B<O_PATH> flag, and the symbolic link is not dereferenced; the B<O_NOFOLLOW> flag, if specified, is ignored.
fr: L'argument I<flags> a la même fonction que pour B<open>(2). Si l'indicateur I<handle> fait référence à un lien symbolique, le processus appelant doit préciser l'attribut B<O_PATH> et le lien symbolique n'est pas déréférencé. L'attribut B<O_NOFOLLOW> est ignoré.

note: type: Plain text
en: The caller must have the B<CAP_DAC_READ_SEARCH> capability to invoke B<open_by_handle_at>().
fr: L'appelant doit avoir la capacité B<CAP_DAC_READ_SEARCH> pour utiliser B<open_by_handle_at>().

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: Plain text
en: On success, B<name_to_handle_at>()  returns 0, and B<open_by_handle_at>()  returns a nonnegative file descriptor.
fr: Lorsqu'il réussit, l'appel B<name_to_handle_at>() renvoie 0 et B<open_by_handle_at>() renvoie un descripteur de fichier positif ou nul.

note: type: Plain text
en: In the event of an error, both system calls return -1 and set I<errno> to indicate the cause of the error.
fr: En cas d'échec, les deux appels renvoient -1 et affectent à I<errno> l'identifiant de la cause de l'échec.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: B<name_to_handle_at>()  and B<open_by_handle_at>()  can fail for the same errors as B<openat>(2).  In addition, they can fail with the errors noted below.
fr: Les appels B<name_to_handle_at>() et B<open_by_handle_at>() peuvent échouer pour les mêmes raisons que B<openat>(2). En outre, ils peuvent également échouer pour les motifs décrits plus bas.

note: type: Plain text
en: B<name_to_handle_at>()  can fail with the following errors:
fr: B<name_to_handle_at>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<pathname>, I<mount_id>, or I<handle> points outside your accessible address space.
fr: I<pathname>, I<mount_id> ou I<handle> pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<flags> includes an invalid bit value.
fr: I<flags> comprend un bit incorrect.

note: type: Plain text
en: I<handle-E<gt>handle_bytes> is greater than B<MAX_HANDLE_SZ>.
fr: I<handle-E<gt>handle_bytes> est supérieur à B<MAX_HANDLE_SZ>.

note: type: Plain text
en: I<pathname> is an empty string, but B<AT_EMPTY_PATH> was not specified in I<flags>.
fr: I<pathname> est une chaîne vide et B<AT_EMPTY_PATH> n’était pas indiqué dans I<flags>.

note: type: Plain text
en: The file descriptor supplied in I<dirfd> does not refer to a directory, and it is not the case that both I<flags> includes B<AT_EMPTY_PATH> and I<pathname> is an empty string.
fr: Le descripteur de fichiers fourni dans I<dirfd> ne fait pas référence à un répertoire, et il ne s'agit pas du cas où I<flags> comprend B<AT_EMPTY_PATH> et I<pathname> est une chaîne vide.

note: type: Plain text
en: The filesystem does not support decoding of a pathname to a file handle.
fr: Le système de fichiers ne permet pas la transcription du chemin de fichier en indicateur de fichier.

note: type: Plain text
en: The I<handle-E<gt>handle_bytes> value passed into the call was too small.  When this error occurs, I<handle-E<gt>handle_bytes> is updated to indicate the required size for the handle.
fr: La valeur I<handle-E<gt>handle_bytes> transmise dans l'appel est trop faible. Lorsque cette erreur se produit, I<handle-E<gt>handle_bytes> est modifié afin d'indiquer la taille requise pour cet indicateur.

note: type: Plain text
en: B<open_by_handle_at>()  can fail with the following errors:
fr: B<open_by_handle_at>() peut échouer avec les erreurs suivantes :

note: type: Plain text
en: I<mount_fd> is not an open file descriptor.
fr: I<mount_fd> n'est pas un descripteur de fichier ouvert.

note: type: Plain text
en: I<handle> points outside your accessible address space.
fr: I<handle> pointe en\(hydehors de l'espace d'adressage accessible.

note: type: Plain text
en: I<handle-E<gt>handle_bytes> is greater than B<MAX_HANDLE_SZ> or is equal to zero.
fr: I<handle-E<gt>handle_bytes> est supérieur à B<MAX_HANDLE_SZ> ou égal à zéro.

note: type: Plain text
en: I<handle> refers to a symbolic link, but B<O_PATH> was not specified in I<flags>.
fr: I<handle> correspond à un lien symbolique et B<O_PATH> n’était pas indiqué dans I<flags>.

note: type: Plain text
en: The caller does not have the B<CAP_DAC_READ_SEARCH> capability.
fr: L'appelant n'a pas la capacité B<CAP_DAC_READ_SEARCH>.

note: type: Plain text
en: The specified I<handle> is not valid.  This error will occur if, for example, the file has been deleted.
fr: La valeur I<handle> indiquée n'est pas correcte. Cet erreur se produit par exemple lorsque le fichier a été supprimé.

note: type: Plain text
en: These system calls first appeared in Linux 2.6.39.  Library support is provided in glibc since version 2.14.
fr: Ces appels système sont apparaus dans Linux 2.6.39. La glibc les gère depuis la version 2.14.

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

note: type: Plain text
en: These system calls are nonstandard Linux extensions.
fr: Ces appels système sont des extensions spécifiques à Linux.

note: type: Plain text
en: FreeBSD has a broadly similar pair of system calls in the form of B<getfh>()  and B<openfh>().
fr: FreeBSD offre un couple d'appel système similaire : B<getfh>() et B<openfh>().

note: type: Plain text
en: A file handle can be generated in one process using B<name_to_handle_at>()  and later used in a different process that calls B<open_by_handle_at>().
fr: Un indicateur de fichier peut être créé dans un processus au moyen de B<name_to_handle_at>() et utilisé plus tard dans un autre processus qui appelle B<open_by_handle_at>().

note: type: Plain text
en: Some filesystem don't support the translation of pathnames to file handles, for example, I</proc>, I</sys>, and various network filesystems.
fr: Certains systèmes de fichiers ne permettent pas la transcription des chemin de fichiers en indicateurs (par exemple, I</proc>, I</sys>, ainsi que divers systèmes de fichiers en réseaux).

note: type: Plain text
en: A file handle may become invalid ("stale") if a file is deleted, or for other filesystem-specific reasons.  Invalid handles are notified by an B<ESTALE> error from B<open_by_handle_at>().
fr: Un indicateur de fichier peut devenir invalide (« stale ») si un fichier est supprimé, ou pour une raison propre au système de fichiers. Les indicateurs invalides sont signalés par une erreur B<ESTALE> provenant de B<open_by_handle_at>().

note: https://lwn.net/Articles/375888/ "Open by handle" - Jonathan Corbet, 2010-02-23 type: Plain text
en: These system calls are designed for use by user-space file servers.  For example, a user-space NFS server might generate a file handle and pass it to an NFS client.  Later, when the client wants to open the file, it could pass the handle back to the server.  This sort of functionality allows a user-space file server to operate in a stateless fashion with respect to the files it serves.
fr: Ces appels systèmes sont conçus pour être utilisés par des serveurs de fichiers en espace utilisateur. Par exemple, un serveur NFS en espace utilisateur produit un indicateur de fichier et le transmet au client NFS. Plus tard, lorsque le client souhaite accéder au fichier en lecture, il peut renvoyer l'indicateur au serveur. Ce type de fonctionnalité permet à un serveur de fichier en espace utilisateur d'opérer sans état vis à vis du fichier qu'il délivre.

note: commit bcda76524cd1fa32af748536f27f674a13e56700 type: Plain text
en: If I<pathname> refers to a symbolic link and I<flags> does not specify B<AT_SYMLINK_FOLLOW>, then B<name_to_handle_at>()  returns a handle for the link (rather than the file to which it refers).  The process receiving the handle can later perform operations on the symbolic link by converting the handle to a file descriptor using B<open_by_handle_at>()  with the B<O_PATH> flag, and then passing the file descriptor as the I<dirfd> argument in system calls such as B<readlinkat>(2)  and B<fchownat>(2).
fr: Si I<pathname> fait référence à un lien symbolique et si I<flags> ne précise pas B<AT_SYMLINK_FOLLOW>, alors B<name_to_handle_at>() renvoie un indicateur pour le lien (plutôt que pour le fichier vers lequel le lien pointe). Le processus recevant l'indicateur peut effectuer plus tard une opération sur ce lien symbolique, en convertissant l'indicateur en descripteur de fichier au moyen de B<open_by_handle_at>() utilisé avec l'argument B<O_PATH>, et en passant le descripteur de fichier en argument I<dirfd> de l'appel système (comme pour B<readlinkat>(2) et B<fchownat>(2)).

note: type: SS
en: Obtaining a persistent filesystem ID
fr: Obtenir un identifiant persistant de système de fichier

note: type: Plain text
en: The mount IDs in I</proc/self/mountinfo> can be reused as filesystems are unmounted and mounted.  Therefore, the mount ID returned by B<name_to_handle_at>()  (in I<*mount_id>)  should not be treated as a persistent identifier for the corresponding mounted filesystem.  However, an application can use the information in the I<mountinfo> record that corresponds to the mount ID to derive a persistent identifier.
fr: Les identifiant de montage de I</proc/self/mountinfo> peuvent être réutilisés même lorsque les systèmes de fichiers sont démontés et remontés. Ainsi, l'identifiant de montage renvoyé par B<name_to_handle_at>() (dans I<*mount_id>) ne doit pas être considéré comme un identifiant persistant pour le système de fichiers considéré. Néanmoins, il est possible pour une application d'utiliser l'information fournie dans I<mountinfo> et correspondant à l'identifiant de montage pour en déduire un identifiant persistant.

note: e.g., http://stackoverflow.com/questions/6748429/using-libblkid-to-find-uuid-of-a-partition type: Plain text
en: For example, one can use the device name in the fifth field of the I<mountinfo> record to search for the corresponding device UUID via the symbolic links in I</dev/disks/by-uuid>.  (A more comfortable way of obtaining the UUID is to use the B<libblkid>(3)  library.)  That process can then be reversed, using the UUID to look up the device name, and then obtaining the corresponding mount point, in order to produce the I<mount_fd> argument used by B<open_by_handle_at>().
fr: Par exemple, on peut utiliser le nom de périphérique présent dans le cinquième champ de I<mountinfo> pour retrouver l'UUID du périphérique correspondant au moyen des liens symboliques de I</dev/disks/by-uuid>. (Un moyen plus simple d'obtenir cet UUID consiste à utiliser la bibliothèque B<libblkid>(3)). Cette façon de procéder peut être inversée, en utilisant l'UUID pour retrouver le nom du périphérique, et ainsi obtenir le point de montage correspondant, et enfin construire l'argument de I<mount_fd> utile à B<open_by_handle_at>().

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The two programs below demonstrate the use of B<name_to_handle_at>()  and B<open_by_handle_at>().  The first program (I<t_name_to_handle_at.c>)  uses B<name_to_handle_at>()  to obtain the file handle and mount ID for the file specified in its command-line argument; the handle and mount ID are written to standard output.
fr: Les deux programmes suivants illustrent l'utilisation de B<name_to_handle_at>() et de B<open_by_handle_at>(). Le premier programme (I<t_name_to_handle_at.c>) utilise B<name_to_handle_at>() pour récupérer l'indicateur de fichier et l'identifiant de montage du fichier indiqué dans les arguments en ligne de commande ; l'indicateur et l'identifiant de montage sont écrits sur la sortie standard.

note: type: Plain text
en: The second program (I<t_open_by_handle_at.c>)  reads a mount ID and file handle from standard input.  The program then employs B<open_by_handle_at>()  to open the file using that handle.  If an optional command-line argument is supplied, then the I<mount_fd> argument for B<open_by_handle_at>()  is obtained by opening the directory named in that argument.  Otherwise, I<mount_fd> is obtained by scanning I</proc/self/mountinfo> to find a record whose mount ID matches the mount ID read from standard input, and the mount directory specified in that record is opened.  (These programs do not deal with the fact that mount IDs are not persistent.)
fr: Le second programme (I<t_open_by_handle_at.c>) lit un identifiant de montage et un indicateur de fichier depuis l'entrée standard. Le programme utilise ensuite B<open_by_handle_at>() pour lire le fichier au moyen de cet indicateur. Si un argument optionnel est fourni dans la ligne de commande, alors l'argument I<mount_fd> de B<open_by_handle_at>() est obtenu en ouvrant le répertoire précisé en argument. Sinon, I<mount_fd> est obtenu en parcourant I</proc/self/mountinfo> à la recherche d'un identifiant de montage correspondant à celui fourni via l'entrée standard, et le répertoire monté qui a été trouvé est ouvert. (Ces programmes ne tiennent pas compte du fait que les identifiants de montage ne sont pas persistants.)

note: type: Plain text
en: The following shell session demonstrates the use of these two programs:
fr: La session shell suivante montre des exemples d'utilisation de ces deux programmes :

note: type: Plain text
en: $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<./t_name_to_handle_at cecilia.txt E<gt> fh>
    $ B<./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Operation not permitted
    $ B<sudo ./t_open_by_handle_at E<lt> fh>      # Need CAP_SYS_ADMIN
    Read 31 bytes
    $ B<rm cecilia.txt>
fr: $ B<echo 'Pouvez-vous réflechir à cela ?' E<gt> cecilia.txt>
    $ B<./t_name_to_handle_at cecilia.txt E<gt> fh>
    $ B<./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Operation non autorisée
    $ B<sudo ./t_open_by_handle_at E<lt> fh>      # Nécessite CAP_SYS_ADMIN
    31 octets lus
    $ B<rm cecilia.txt>

note: Christoph Hellwig: That's why the file handles contain a generation counter that gets incremented in this case. type: Plain text
en: Now we delete and (quickly) re-create the file so that it has the same content and (by chance) the same inode.  Nevertheless, B<open_by_handle_at>()  recognizes that the original file referred to by the file handle no longer exists.
fr: A ce stade, on supprime et recrée (rapidement) le fichier, de sorte qu'il ait le même contenu et (avec un peu de chance) le même inoeud. Cependant, B<open_by_handle_at>() s'aperçoit que le fichier original auquel l'indicateur fait référence n'existe plus.

note: type: Plain text
en: $ B<stat --printf="%i\en" cecilia.txt>     # Display inode number
    4072121
    $ B<rm cecilia.txt>
    $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<stat --printf="%i\en" cecilia.txt>     # Check inode number
    4072121
    $ B<sudo ./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Stale NFS file handle
fr: $ B<stat --printf="%i\en" cecilia.txt>     # affiche le numéro d'inoeud
    4072121
    $ B<rm cecilia.txt>
    $ B<echo 'Can you please think about it?' E<gt> cecilia.txt>
    $ B<stat --printf="%i\en" cecilia.txt>     # Vérifie le numéro d'inoeud
    4072121
    $ B<sudo ./t_open_by_handle_at E<lt> fh>
    open_by_handle_at: Stale NFS file handle

note: type: SS
en: Program source: t_name_to_handle_at.c
fr: Source du programme : t_name_to_handle_at.c

note: type: Plain text
en:     /* Allocate file_handle structure */
fr:     /* Alloue la structure file_handle */

note: type: Plain text
en:     /* Make an initial call to name_to_handle_at() to discover
           the size required for file handle */
fr:     /* Effectue un appel initial à name_to_handle_at() afin de connaître
           la taille nécessaire à l'indicateur de fichier */

note: type: Plain text
en:     dirfd = AT_FDCWD;           /* For name_to_handle_at() calls */
        flags = 0;                  /* For name_to_handle_at() calls */
        fhp-E<gt>handle_bytes = 0;
        if (name_to_handle_at(dirfd, pathname, fhp,
                    &mount_id, flags) != -1 || errno != EOVERFLOW) {
            fprintf(stderr, "Unexpected result from name_to_handle_at()\en");
            exit(EXIT_FAILURE);
        }
fr:     dirfd = AT_FDCWD;           /* pour les appels à name_to_handle_at() */
        flags = 0;                  /* Pour les appels à  name_to_handle_at() */
        fhp-E<gt>handle_bytes = 0;
        if (name_to_handle_at(dirfd, pathname, fhp,
                    &mount_id, flags) != -1 || errno != EOVERFLOW) {
            fprintf(stderr, "Unexpected result from name_to_handle_at()\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Reallocate file_handle structure with correct size */
fr:     /* Ré-alloue la structure file_handle avec la bonne taille */

note: type: Plain text
en:     fhsize = sizeof(struct file_handle) + fhp-E<gt>handle_bytes;
        fhp = realloc(fhp, fhsize);         /* Copies fhp-E<gt>handle_bytes */
        if (fhp == NULL)
            errExit("realloc");
fr:     fhsize = sizeof(struct file_handle) + fhp-E<gt>handle_bytes;
        fhp = realloc(fhp, fhsize);         /* Copie fhp-E<gt>handle_bytes */
        if (fhp == NULL)
            errExit("realloc");

note: type: Plain text
en:     /* Get file handle from pathname supplied on command line */
fr:     /* Retrouve l'indicateur de fichier à partir
           du chemin fourni dans la ligne de commande */

note: type: Plain text
en:     /* Write mount ID, file handle size, and file handle to stdout,
           for later reuse by t_open_by_handle_at.c */
fr:     /* Écrit l'identifiant de montage, la taille de l'indicateur et
           l'indicateur vers la sortie standard
           pour être utilisé plus tard par t_open_by_handle_at.c */

note: type: SS
en: Program source: t_open_by_handle_at.c
fr: Source du programme : t_open_by_handle_at.c

note: type: Plain text
en: /* Scan /proc/self/mountinfo to find the line whose mount ID matches
       \(aqmount_id\(aq. (An easier way to do this is to install and use the
       \(aqlibmount\(aq library provided by the \(aqutil-linux\(aq project.)
       Open the corresponding mount path and return the resulting file
       descriptor. */
fr: /* Parcourt /proc/self/mountinfo pour trouver la ligne correspondant à 
       l'ID de montage \(aqmount_id\(aq. (Une méthode plus simple consiste à
       installer et à utiliser la bibliothèque (aqlibmount\(aq fournie par le
       projet \(aqutil-linux\(aq.)
       Ouvre le point de montage correspondant et renvoie le descripteur de fichier associé. */

note: type: Plain text
en:     if (!found) {
            fprintf(stderr, "Could not find mount point\en");
            exit(EXIT_FAILURE);
        }
fr:     if (!found) {
            fprintf(stderr, "Point de montage non trouvé\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Standard input contains mount ID and file handle information:
fr:     /* L'entrée standard contient l'identifiant de montage et les informations du l'indicateur :

note: type: Plain text
en:          Line 1: E<lt>mount_idE<gt>
             Line 2: E<lt>handle_bytesE<gt> E<lt>handle_typeE<gt>   E<lt>bytes of handle in hexE<gt>
        */
fr:          Ligne 1: E<lt>mount_idE<gt>
             Ligne 2: E<lt>handle_bytesE<gt> E<lt>handle_typeE<gt>   E<lt>octets du descripteur en hexadécimalE<gt>
        */

note: type: Plain text
en:     if ((fgets(line1, sizeof(line1), stdin) == NULL) ||
               (fgets(line2, sizeof(line2), stdin) == NULL)) {
            fprintf(stderr, "Missing mount_id / file handle\en");
            exit(EXIT_FAILURE);
        }
fr:     if ((fgets(line1, sizeof(line1), stdin) == NULL) ||
               (fgets(line2, sizeof(line2), stdin) == NULL)) {
            fprintf(stderr, "mount_id ou descripteur de fichier absent\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Given handle_bytes, we can now allocate file_handle structure */
fr:     /* handle_bytes étant connu, on peut maintenant allouer la structure file_handle */

note: type: Plain text
en:     /* Obtain file descriptor for mount point, either by opening
           the pathname specified on the command line, or by scanning
           /proc/self/mounts to find a mount that matches the \(aqmount_id\(aq
           that we received from stdin. */
fr:     /* Récupère le descripteur de fichier du point de montage, soit en ouvrant
           le chemin indiqué dans la ligne de commande, soit en parcourant
           /proc/self/mounts pour retrouver un montage qui corresponde à \(aqmount_id\(aq
           qui a été reçu de stdin. */

note: type: Plain text
en:     /* Open file using handle and mount point */
fr:     /* Ouvre le fichier en utilisant l'indicateur et le point de montage */

note: type: Plain text
en:     /* Try reading a few bytes from the file */
fr:     /* On essaie de lire quelques octets depuis le fichier */

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

note: type: Plain text
en: The I<libblkid> and I<libmount> documentation in the latest I<util-linux> release at E<.UR https://www.kernel.org/pub/linux/utils/util-linux/> E<.UE>
fr: La document relative à I<libblkid> et à I<libmount> de la dernière publication de I<util-linux> à E<.UR https://www.kernel.org/pub/linux/utils/util-linux/> E<.UE>

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

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

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