perkamon - en to fr translation catalogue (124 entries)

note: type: TH
en: 2019-08-02
fr: 2 août 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: fanotify - monitoring filesystem events
fr: fanotify - Surveiller les événements des systèmes de fichiers

note: type: Plain text
en: The fanotify API provides notification and interception of filesystem events.  Use cases include virus scanning and hierarchical storage management.  Currently, only a limited set of events is supported.  In particular, there is no support for create, delete, and move events.  (See B<inotify>(7)  for details of an API that does notify those events.)
fr: L’interface de programmation fanotify permet d’être notifié et d’intercepter les événements de systèmes de fichiers. La recherche de virus et la gestion de stockage hiérarchisé font partie des cas d’utilisation. Actuellement, seul un ensemble limité d’événements est pris en charge. En particulier, les événements de création, suppression ou plus ne sont pas pris en charge (consultez B<inotify>(7) pour plus de précisions sur une interface de programmation qui permet d’être notifié de ces événements).

note: type: Plain text
en: Additional capabilities compared to the B<inotify>(7)  API include the ability to monitor all of the objects in a mounted filesystem, the ability to make access permission decisions, and the possibility to read or modify files before access by other applications.
fr: La capacité de surveiller tous les objets d’un système de fichiers monté, la capacité de décider des droits d’accès et la possibilité de lire ou modifier les fichiers avant qu’ils ne soient accédé par d’autres applications font partie des capacités supplémentaires à l’interface de programmation B<inotify>(7).

note: type: Plain text
en: The following system calls are used with this API: B<fanotify_init>(2), B<fanotify_mark>(2), B<read>(2), B<write>(2), and B<close>(2).
fr: Les appels système suivants sont utilisés avec cette interface de programmation : B<fanotify_init>(2), B<fanotify_mark>(2), B<read>(2), B<write>(2) et B<close>(2).

note: type: SS
en: fanotify_init(), fanotify_mark(), and notification groups
fr: fanotify_init(), fanotify_mark() et groupes de notification

note: type: Plain text
en: The B<fanotify_init>(2)  system call creates and initializes an fanotify notification group and returns a file descriptor referring to it.
fr: L’appel système B<fanotify_init>(2) crée et initialise un groupe de notifications fanotify et renvoie un descripteur de fichier le référençant.

note: type: Plain text
en: A possible usage of the ignore mask is for a file cache.  Events of interest for a file cache are modification of a file and closing of the same.  Hence, the cached directory or mount point is to be marked to receive these events.  After receiving the first event informing that a file has been modified, the corresponding cache entry will be invalidated.  No further modification events for this file are of interest until the file is closed.  Hence, the modify event can be added to the ignore mask.  Upon receiving the close event, the modify event can be removed from the ignore mask and the file cache entry can be updated.
fr: Le masque ignore peut servir pour un cache de fichier. Les événements intéressants pour un cache de fichier sont la modification et la fermeture d’un fichier. Ainsi, le répertoire ou point de montage en cache va être marqué pour recevoir ces événements. Après la réception du premier événement informant qu’un fichier a été modifié, l’entrée correspondante du cache sera désactivée. Aucun autre événement de modification pour ce fichier ne sera utile jusqu’à sa fermeture. Ainsi, l’événement de modification peut être ajouté au masque ignore. Lors de la réception d’un événement de fermeture, l’événement de modification peut être supprimé du masque ignore et l’entrée de cache de fichier peut être mise à jour.

note: type: SS
en: The event queue
fr: La file d’événements

note: type: Plain text
en: As events occur on the filesystem objects monitored by a notification group, the fanotify system generates events that are collected in a queue.  These events can then be read (using B<read>(2)  or similar)  from the fanotify file descriptor returned by B<fanotify_init>(2).
fr: Comme les événements surviennent sur les objets de système de fichiers surveillés par un groupe de notifications, le système fanotify génère les événements qui sont collectés dans une file. Ces événements peuvent être lus (en utilisant B<read>(2) ou similaire) à partir du descripteur de fichier fanotify renvoyé par B<fanotify_init>(2).

note: type: Plain text
en: An event is removed from the event queue of the fanotify group when it has been read.  Permission events that have been read are kept in an internal list of the fanotify group until either a permission decision has been taken by writing to the fanotify file descriptor or the fanotify file descriptor is closed.
fr: Un événement est supprimé de la file d’événements du groupe fanotify quand il a été lu. Les événements de permission qui ont été lus sont gardés dans une liste interne du groupe fanotify jusqu’à ce qu’une décision d’attribution de droits ait été prise en écrivant dans le descripteur de fichier fanotify ou que le descripteur de fichier fanotify soit fermé.

note: type: SS
en: Reading fanotify events
fr: Lecture d’événements fanotify

note: type: Plain text
en: Calling B<read>(2)  for the file descriptor returned by B<fanotify_init>(2)  blocks (if the flag B<FAN_NONBLOCK> is not specified in the call to B<fanotify_init>(2))  until either a file event occurs or the call is interrupted by a signal (see B<signal>(7)).
fr: Appeler B<read>(2) pour le descripteur de fichier renvoyé par B<fanotify_init>(2) bloque (si l’attribut B<FAN_NONBLOCK> n’est pas indiqué dans l’appel de B<fanotify_init>(2)) jusqu’à ce qu’un événement de fichier survienne ou que l’appel soit interrompu par un signal (consultez B<signal>(7)).

note: type: Plain text
en: For performance reasons, it is recommended to use a large buffer size (for example, 4096 bytes), so that multiple events can be retrieved by a single B<read>(2).
fr: Pour des raisons de performances, une grande taille de tampon (par exemple 4096 octets) est conseillée pour que plusieurs événements puissent être récupérés en une seul lecture.

note: type: Plain text
en: The return value of B<read>(2)  is the number of bytes placed in the buffer, or -1 in case of an error (but see BUGS).
fr: La valeur de retour de B<read>(2) est le nombre d’octets placés dans le tampon, ou -1 en cas d’erreur (mais consultez B<BOGUES>).

note: type: Plain text
en: The fields of the I<fanotify_event_metadata> structure are as follows:
fr: Les champs de la structure I<fanotify_event_metadata> sont les suivants.

note: type: Plain text
en: This field holds a version number for the structure.  It must be compared to B<FANOTIFY_METADATA_VERSION> to verify that the structures returned at run time match the structures defined at compile time.  In case of a mismatch, the application should abandon trying to use the fanotify file descriptor.
fr: Ce champ contient un numéro de version pour la structure. Il doit être comparé à B<FANOTIFY_METADATA_VERSION> pour vérifier que les structures renvoyées pendant l’exécution correspondent aux structures définies à la compilation. En cas d’erreur de correspondance, l’application devrait arrêter d’essayer d’utiliser le descripteur de fichier fanotify.

note: type: Plain text
en: This field is not used.
fr: Ce champ n’est pas utilisé.

note: type: Plain text
en: This is the length of the structure.  The field was introduced to facilitate the implementation of optional headers per event type.  No such optional headers exist in the current implementation.
fr: C’est la taille de la structure. Le champ a été introduit pour faciliter l’implémentation d’en-têtes facultatifs par type d’événements. Aucun en-tête facultatif n’existe dans l’implémentation actuelle.

note: type: Plain text
en: This is a bit mask describing the event (see below).
fr: C’est un masque binaire décrivant l’événement (voir ci-dessous).

note: type: Plain text
en: When calling B<fanotify_init>(2), the caller may specify (via the I<event_f_flags> argument) various file status flags that are to be set on the open file description that corresponds to this file descriptor.  In addition, the (kernel-internal)  B<FMODE_NONOTIFY> file status flag is set on the open file description.  This flag suppresses fanotify event generation.  Hence, when the receiver of the fanotify event accesses the notified file or directory using this file descriptor, no additional events will be created.
fr: Lors d’un appel de B<fanotify_init>(2), l’appelant pourrait indiquer (à l’aide de l’argument I<event_f_flags>) plusieurs attributs d’état de fichier à définir dans la description de fichier ouverte qui correspond à ce descripteur de fichier. De plus, l’attribut d’état de fichier B<FMODE_NONOTIFY> (interne au noyau) est défini dans la description de fichier ouverte. L’attribut supprime la création d’événement fanotify. Ainsi, quand le destinataire de l’événement fanotify accède au fichier ou répertoire notifiés en utilisant ce descripteur de fichier, aucun événement supplémentaire n’est créé.

note: type: Plain text
en: The bit mask in I<mask> indicates which events have occurred for a single filesystem object.  Multiple bits may be set in this mask, if more than one event occurred for the monitored filesystem object.  In particular, consecutive events for the same filesystem object and originating from the same process may be merged into a single event, with the exception that two permission events are never merged into one queue entry.
fr: Le masque binaire de I<mask> indique les événements survenus pour un seul objet de système de fichiers. Plusieurs bits pourraient être définis dans ce masque si plus d’un événement est survenu pour l’objet de système de fichiers surveillé. En particulier, les événements consécutifs pour le même objet de système de fichiers et originaire du même processus pourraient être fusionnés dans un seul événement, mais deux événements de permission ne sont jamais fusionnés dans une entrée de file.

note: type: Plain text
en: The bits that may appear in I<mask> are as follows:
fr: Les bits pouvant apparaître dans I<mask> sont les suivants.

note: type: Plain text
en: A file or a directory (but see BUGS) was accessed (read).
fr: Un fichier ou un répertoire (mais consultez B<BOGUES>) a été accédé (en lecture).

note: type: Plain text
en: A file or a directory was opened.
fr: Un fichier ou un répertoire a été ouvert.

note: type: Plain text
en: A file was modified.
fr: Un fichier a été modifié.

note: type: Plain text
en: A file that was opened for writing (B<O_WRONLY> or B<O_RDWR>)  was closed.
fr: Un fichier qui était ouvert en écriture (B<O_WRONLY> ou B<O_RDWR>) a été fermé.

note: type: Plain text
en: A file or directory that was opened read-only (B<O_RDONLY>)  was closed.
fr: Soit un fichier, soit un répertoire, qui était ouvert en lecture seule (B<O_RDONLY>), a été fermé.

note: type: Plain text
en: The event queue exceeded the limit of 16384 entries.  This limit can be overridden by specifying the B<FAN_UNLIMITED_QUEUE> flag when calling B<fanotify_init>(2).
fr: La file d’événements a dépassé la limite de 16384 entrées. Cette limite peut être écrasée en indiquant l’attribut B<FAN_UNLIMITED_QUEUE> lors de l’appel de B<fanotify_init>(2).

note: type: Plain text
en: An application wants to read a file or directory, for example using B<read>(2)  or B<readdir>(2).  The reader must write a response (as described below)  that determines whether the permission to access the filesystem object shall be granted.
fr: Une application veut lire un fichier ou répertoire, par exemple en utilisant B<read>(2) ou B<readdir>(2). Le lecteur doit écrire une réponse (telle que décrite ci-dessous) qui détermine si le droit d’accès à l’objet de système de fichiers sera attribué.

note: type: Plain text
en: An application wants to open a file or directory.  The reader must write a response that determines whether the permission to open the filesystem object shall be granted.
fr: Une application veut ouvrir un fichier ou un répertoire. Le lecteur doit écrire une réponse qui détermine si le droit d’ouvrir l’objet de système de fichiers sera attribué.

note: type: Plain text
en: To check for any close event, the following bit mask may be used:
fr: Pour vérifier tous les événements fermés, le masque binaire suivant pourrait être utilisé :

note: type: Plain text
en: A file was closed.  This is a synonym for:
fr: Un fichier a été fermé. C’est un synonyme de :

note: type: Plain text
en: The following macros are provided to iterate over a buffer containing fanotify event metadata returned by a B<read>(2)  from an fanotify file descriptor:
fr: Les macros suivantes sont fournies pour itérer sur un tampon contenant les métadonnées d’événement fanotify renvoyées par B<read>(2) à partir d’un descripteur de fichier fanotify.

note: type: Plain text
en: This macro checks the remaining length I<len> of the buffer I<meta> against the length of the metadata structure and the I<event_len> field of the first metadata structure in the buffer.
fr: Cette macro compare la taille restante I<len> du tampon I<meta> à la taille de la structure de métadonnées et au champ I<event_len> de la première structure de métadonnées du tampon.

note: type: Plain text
en: This macro uses the length indicated in the I<event_len> field of the metadata structure pointed to by I<meta> to calculate the address of the next metadata structure that follows I<meta>.  I<len> is the number of bytes of metadata that currently remain in the buffer.  The macro returns a pointer to the next metadata structure that follows I<meta>, and reduces I<len> by the number of bytes in the metadata structure that has been skipped over (i.e., it subtracts I<meta-E<gt>event_len> from I<len>).
fr: Cette macro utilise la taille indiquée dans le champ I<event_len> de la structure de métadonnées pointée par I<meta> pour calculer l’adresse de la prochaine structure de métadonnées qui suit I<meta>. I<len> est le nombre d’octets de métadonnées qui restent actuellement dans le tampon. La macro renvoie un pointeur vers la prochaine structure de métadonnées qui suit I<meta> et réduit I<len> du nombre d’octets dans la structure de métadonnées qui a été sautée (c’est-à-dire qu’elle soustrait I<meta-E<gt>event_len> de I<len>).

note: type: Plain text
en: In addition, there is:
fr: De plus, il y a :

note: type: Plain text
en: This macro returns the size (in bytes) of the structure I<fanotify_event_metadata>.  This is the minimum size (and currently the only size) of any event metadata.
fr: Cette macro renvoie la taille (en octet) de la structure I<fanotify_event_metadata>. C’est la taille minimale (et actuellement la seule taille) de métadonnées d’événements.

note: type: SS
en: Monitoring an fanotify file descriptor for events
fr: Surveiller un descripteur de fichier fanotify pour les événements

note: type: Plain text
en: When an fanotify event occurs, the fanotify file descriptor indicates as readable when passed to B<epoll>(7), B<poll>(2), or B<select>(2).
fr: Quand un événement fanotify survient, le descripteur de fichier fanotify est indiqué comme lisible lorsque passé à B<epoll>(7), B<poll>(2) ou B<select>(2).

note: type: SS
en: Dealing with permission events
fr: Traitement des événements de permission

note: type: Plain text
en: For permission events, the application must B<write>(2)  a structure of the following form to the fanotify file descriptor:
fr: Pour les événements de permission, l’application doit écrire (avec B<write>(2)) une structure de la forme suivant sur le descripteur de fichier fanotify :

note: type: Plain text
en: The fields of this structure are as follows:
fr: Les champs de cette structure sont les suivants.

note: type: Plain text
en: This is the file descriptor from the structure I<fanotify_event_metadata>.
fr: C’est le descripteur de fichier de la structure I<fanotify_event_metadata>.

note: type: Plain text
en: This field indicates whether or not the permission is to be granted.  Its value must be either B<FAN_ALLOW> to allow the file operation or B<FAN_DENY> to deny the file operation.
fr: Ce champ indique si les droits doivent être attribués ou non. Cette valeur doit être soit B<FAN_ALLOW> pour permettre l’opération de fichier, soit B<FAN_DENY> pour refuser l’opération de fichier.

note: type: Plain text
en: If access is denied, the requesting application call will receive an B<EPERM> error.
fr: Si l’accès est refusé, l’appel d’application faisant la demande recevra une erreur B<EPERM>.

note: type: SS
en: Closing the fanotify file descriptor
fr: Fermeture du descripteur de fichier fanotify

note: type: Plain text
en: When all file descriptors referring to the fanotify notification group are closed, the fanotify group is released and its resources are freed for reuse by the kernel.  Upon B<close>(2), outstanding permission events will be set to allowed.
fr: Quand tous les descripteurs de fichier se référant au groupe de notifications fanotify sont fermés, le groupe fanotify est libéré et ses ressources sont libérées pour être réutilisées par le noyau. Lors de l’appel de B<close>(2), les événements de permission restants seront définis à permis.

note: type: Plain text
en: The file I</proc/[pid]/fdinfo/[fd]> contains information about fanotify marks for file descriptor I<fd> of process I<pid>.  See B<proc>(5)  for details.
fr: Le fichier I</proc/[pid]/fdinfo/[fd]> contient des renseignements sur les marques fanotify pour le descripteur de fichier I<fd> du processus I<pid>. Consultez B<proc>(5) pour plus de précisions.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: In addition to the usual errors for B<read>(2), the following errors can occur when reading from the fanotify file descriptor:
fr: En plus des erreurs habituelles de B<read>(2), les erreurs suivantes peuvent survenir lors de la lecture d’un descripteur de fichier fanotify.

note: type: Plain text
en: The buffer is too small to hold the event.
fr: Le tampon est trop petit pour contenir l’événement.

note: type: Plain text
en: The per-process limit on the number of open files has been reached.  See the description of B<RLIMIT_NOFILE> in B<getrlimit>(2).
fr: La limite par processus du nombre de fichiers ouverts a été atteinte. Consultez la description de B<RLIMIT_NOFILE> dans B<getrlimit>(2).

note: type: Plain text
en: The system-wide limit on the total number of open files has been reached.  See I</proc/sys/fs/file-max> in B<proc>(5).
fr: La limite du nombre de fichiers ouverts sur le système a été atteinte. Consultez I</proc/sys/fs/file-max> dans B<proc>(5).

note: type: Plain text
en: This error is returned by B<read>(2)  if B<O_RDWR> or B<O_WRONLY> was specified in the I<event_f_flags> argument when calling B<fanotify_init>(2)  and an event occurred for a monitored file that is currently being executed.
fr: Cette erreur est renvoyée par B<read>(2) si B<O_RDWR> ou B<O_WRONLY> ont été indiqués dans l’argument I<event_f_flags> lors de l’appel B<fanotify_init>(2) et qu’un événements est survenu pour un fichier surveillé actuellement en cours d’exécution.

note: type: Plain text
en: In addition to the usual errors for B<write>(2), the following errors can occur when writing to the fanotify file descriptor:
fr: En plus des erreurs habituelles de B<write>(2), les erreurs suivantes peuvent survenir lors de l’écriture sur un descripteur de fichier fanotify.

note: type: Plain text
en: Fanotify access permissions are not enabled in the kernel configuration or the value of I<response> in the response structure is not valid.
fr: Les droits d’accès fanotify ne sont pas activés dans la configuration du noyau ou la valeur de I<response> dans la structure de réponse n’est pas valable.

note: type: Plain text
en: The file descriptor I<fd> in the response structure is not valid.  This may occur when a response for the permission event has already been written.
fr: Le descripteur de fichier I<fd> dans la structure de réponse n’est pas valable. Cela pourrait survenir quand une réponse pour l’événement de permission a déjà été écrite.

note: type: Plain text
en: The fanotify API was introduced in version 2.6.36 of the Linux kernel and enabled in version 2.6.37.  Fdinfo support was added in version 3.8.
fr: L’interface de programmation fanotify a été introduite dans la version 2.6.36 du noyau Linux et activée dans la version 2.6.37. La prise en charge de fdinfo a été ajoutée dans la version 3.8.

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

note: type: Plain text
en: The fanotify API is Linux-specific.
fr: L’interface de programmation fanotify est spécifique à Linux.

note: type: Plain text
en: The fanotify API is available only if the kernel was built with the B<CONFIG_FANOTIFY> configuration option enabled.  In addition, fanotify permission handling is available only if the B<CONFIG_FANOTIFY_ACCESS_PERMISSIONS> configuration option is enabled.
fr: L’interface de programmation fanotify n’est disponible que si le noyau a été construit avec l’option de configuration B<CONFIG_FANOTIFY> activée. De plus, le traitement de permission fanotify n’est disponible que si l’option de configuration B<CONFIG_FANOTIFY_ACCESS_PERMISSIONS> est activée.

note: type: SS
en: Limitations and caveats
fr: Limites et réserves

note: type: Plain text
en: Fanotify reports only events that a user-space program triggers through the filesystem API.  As a result, it does not catch remote events that occur on network filesystems.
fr: Fanotify ne signale que les événements déclenchés par un programme en espace utilisateur à l’aide d’une interface de programmation de système de fichiers. Par conséquent, elle n’intercepte pas les événements qui surviennent sur les systèmes de fichiers en réseau.

note: type: Plain text
en: The fanotify API does not report file accesses and modifications that may occur because of B<mmap>(2), B<msync>(2), and B<munmap>(2).
fr: L'interface fanotify ne signale pas les accès ni les modifications de fichier qui pourraient survenir à cause de B<mmap>(2), B<msync>(2) ou B<munmap>(2).

note: type: Plain text
en: Events for directories are created only if the directory itself is opened, read, and closed.  Adding, removing, or changing children of a marked directory does not create events for the monitored directory itself.
fr: Les événements pour répertoires ne sont créés que si le répertoire lui-même est ouvert, lu et fermé. Ajouter, supprimer ou modifier les enfants d’un répertoire marqué ne crée pas d’événement pour le répertoire surveillé lui-même.

note: type: Plain text
en: The event queue can overflow.  In this case, events are lost.
fr: La file d'événements peut déborder. Dans ce cas, les événements sont perdus.

note: type: SH
en: BUGS
fr: BOGUES

note: commit 820c12d5d6c0890bc93dd63893924a13041fdc35 type: Plain text
en: Before Linux 3.19, B<fallocate>(2)  did not generate fanotify events.  Since Linux 3.19, calls to B<fallocate>(2)  generate B<FAN_MODIFY> events.
fr: Avant Linux 3.19, B<fallocate>(2) ne créait pas d'événement fanotify. Depuis Linux 3.19, les appels à B<fallocate>(2) créent des événements B<FAN_MODIFY>.

note: type: Plain text
en: As of Linux 3.17, the following bugs exist:
fr: Dans Linux 3.17, les bogues suivants existent :

note: type: Plain text
en: On Linux, a filesystem object may be accessible through multiple paths, for example, a part of a filesystem may be remounted using the I<--bind> option of B<mount>(8).  A listener that marked a mount will be notified only of events that were triggered for a filesystem object using the same mount.  Any other event will pass unnoticed.
fr: Dans Linux, un objet de système de fichiers pourrait être accessible par de multiples chemins. Par exemple, une partie d'un système de fichiers pourrait être remontée avec l'option I<--bind> de B<mount>(8). Un écoutant ayant marqué un montage ne sera notifié que des événements déclenchés pour le système de fichiers utilisant le même montage. Tout autre événement passera inaperçu.

note: FIXME . A patch was proposed. type: Plain text
en: When an event is generated, no check is made to see whether the user ID of the receiving process has authorization to read or write the file before passing a file descriptor for that file.  This poses a security risk, when the B<CAP_SYS_ADMIN> capability is set for programs executed by unprivileged users.
fr: Quand un événement est créé, aucune vérification n’est effectuée pour voir si l’identifiant utilisateur du processus recevant a le droit de lire ou écrire le fichier avant de passer un descripteur de fichier pour ce fichier. Cela pose un risque de sécurité quand la capacité B<CAP_SYS_ADMIN> est définie pour un programme exécuté par les utilisateurs ordinaires ;

note: type: Plain text
en: If a call to B<read>(2)  processes multiple events from the fanotify queue and an error occurs, the return value will be the total length of the events successfully copied to the user-space buffer before the error occurred.  The return value will not be -1, and I<errno> will not be set.  Thus, the reading application has no way to detect the error.
fr: Si un appel de B<read>(2) traite plusieurs événements de la file fanotify et qu’une erreur survient, la valeur de retour sera la taille totale des événements copiés correctement dans le tampon d’espace utilisateur avant que l’erreur ne survienne. La valeur de retour ne sera pas -1 et I<errno> ne sera pas définie. Ainsi, l’application lisant n’a aucun moyen de détecter l’erreur.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: Listening for events stopped.
fr: Arrêt de l’écoute d’événements.

note: type: Plain text
en: #define _GNU_SOURCE     /* Needed to get O_LARGEFILE definition */
    #include E<lt>errno.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>poll.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/fanotify.hE<gt>
    #include E<lt>unistd.hE<gt>
fr: /* Nécessaire pour obtenir la définition de O_LARGEFILE */
    #define _GNU_SOURCE
    
    #include E<lt>errno.hE<gt>
    #include E<lt>fcntl.hE<gt>
    #include E<lt>limits.hE<gt>
    #include E<lt>poll.hE<gt>
    #include E<lt>stdio.hE<gt>
    #include E<lt>stdlib.hE<gt>
    #include E<lt>sys/fanotify.hE<gt>
    #include E<lt>unistd.hE<gt>

note: type: Plain text
en:     /* Loop while events can be read from fanotify file descriptor */
fr:     /* Boucler tant que les événements peuvent être lus à partir du
           descripteur de fichier fanotify */

note: type: Plain text
en:         /* Read some events */
fr:         /* Lire certains événements */

note: type: Plain text
en:         /* Check if end of available data reached */
fr:         /* Vérifier si la fin des données disponibles est atteinte */

note: type: Plain text
en:         /* Point to the first event in the buffer */
fr:         /* Pointer vers le premier événement du tampon */

note: type: Plain text
en:         /* Loop over all events in the buffer */
fr:         /* Boucler sur tous les événements du tampon */

note: type: Plain text
en:             /* Check that run-time and compile-time structures match */
fr:             /* Vérifier que les structures au moment de l’exécution et
                   de la compilation correspondent */

note: type: Plain text
en:             if (metadata-E<gt>vers != FANOTIFY_METADATA_VERSION) {
                    fprintf(stderr,
                            "Mismatch of fanotify metadata version.\en");
                    exit(EXIT_FAILURE);
                }
fr:             if (metadata-E<gt>vers != FANOTIFY_METADATA_VERSION) {
                    fprintf(stderr,
                "Non correspondance de version de métadonnées fanotify.\en");
                    exit(EXIT_FAILURE);
                }

note: type: Plain text
en:             /* metadata-E<gt>fd contains either FAN_NOFD, indicating a
                   queue overflow, or a file descriptor (a nonnegative
                   integer). Here, we simply ignore queue overflow. */
fr:             /* metadata-E<gt>fd contient soit FAN_NOFD, indiquant un
                   dépassement de file, soit un descripteur de fichier
                   (un entier positif).
                   Ici, le dépassement de file est simplement ignoré. */

note: type: Plain text
en:                 /* Handle open permission event */
fr:                 /* Traiter l’événement de permission d’ouverture */

note: type: Plain text
en:                 if (metadata-E<gt>mask & FAN_OPEN_PERM) {
                        printf("FAN_OPEN_PERM: ");
fr:                 if (metadata-E<gt>mask & FAN_OPEN_PERM) {
                        printf("FAN_OPEN_PERM : ");

note: type: Plain text
en:                     /* Allow file to be opened */
fr:                     /* Permettre d’ouvrir le fichier */

note: type: Plain text
en:                 /* Handle closing of writable file event */
fr:                 /* Traiter l’événement de fermeture de fichier ouvert
                       en écriture */

note: type: Plain text
en:                 if (metadata-E<gt>mask & FAN_CLOSE_WRITE)
                        printf("FAN_CLOSE_WRITE: ");
fr:                 if (metadata-E<gt>mask & FAN_CLOSE_WRITE)
                        printf("FAN_CLOSE_WRITE : ");

note: type: Plain text
en:                 /* Retrieve and print pathname of the accessed file */
fr:                 /* Récupérer et afficher le chemin du fichier accédé */

note: type: Plain text
en:                 /* Close the file descriptor of the event */
fr:                 /* Fermer le descripteur de fichier de l’événement */

note: type: Plain text
en:             /* Advance to next event */
fr:             /* Avancer au prochain événement */

note: type: Plain text
en:     /* Check mount point is supplied */
fr:     /* Vérifier qu’un point de montage est fourni */

note: type: Plain text
en:     if (argc != 2) {
            fprintf(stderr, "Usage: %s MOUNT\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc != 2) {
            fprintf(stderr, "Utilisation : %s MONTAGE\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     printf("Press enter key to terminate.\en");
fr:     printf("Appuyer sur la touche Entrée pour quitter.\en");

note: type: Plain text
en:     /* Create the file descriptor for accessing the fanotify API */
fr:     /* Créer le descripteur de fichier pour accéder à l’interface de
           programmation fanotify */

note: type: Plain text
en:     /* Mark the mount for:
           - permission events before opening files
           - notification events after closing a write-enabled
             file descriptor */
fr:     /* Marquer le montage pour :
           - les événements de permission avant d’ouvrir les fichiers ;
           - les événements de notification après fermeture de descripteur
             de fichier ouvert en écriture. */

note: type: Plain text
en:     /* Prepare for polling */
fr:     /* Préparer pour la scrutation (polling) */

note: type: Plain text
en:     /* Console input */
fr:     /* Entrée de console */

note: type: Plain text
en:     /* Fanotify input */
fr:     /* Entrée de fanotify */

note: type: Plain text
en:     /* This is the loop to wait for incoming events */
fr:     /* Boucle en attente d’arrivée d’événements */

note: type: Plain text
en:     printf("Listening for events.\en");
fr:     printf("En écoute d’événements.\en");

note: type: Plain text
en:     while (1) {
            poll_num = poll(fds, nfds, -1);
            if (poll_num == -1) {
                if (errno == EINTR)     /* Interrupted by a signal */
                    continue;           /* Restart poll() */
fr:     while (1) {
            poll_num = poll(fds, nfds, -1);
            if (poll_num == -1) {
                if (errno == EINTR)     /* Interrompu par un signal */
                    continue;           /* Redémarrage de poll() */

note: type: Plain text
en:             perror("poll");         /* Unexpected error */
                exit(EXIT_FAILURE);
            }
fr:             perror("poll");         /* Erreur inattendue */
                exit(EXIT_FAILURE);
            }

note: type: Plain text
en:                 /* Console input is available: empty stdin and quit */
fr:                 /* Entrée de console disponible :
                       vider l’entrée standard et quitter */

note: type: Plain text
en:                 /* Fanotify events are available */
fr:                 /* Des événements fanotify sont disponibles */

note: type: Plain text
en:     printf("Listening for events stopped.\en");
        exit(EXIT_SUCCESS);
    }
fr:     printf("Arrêt de l’écoute d’événements.\en");
        exit(EXIT_SUCCESS);
    }

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

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: TH
en: 2019-03-06
fr: 6 mars 2019

note: type: Plain text
en: Two types of events are generated: I<notification> events and I<permission> events.  Notification events are merely informative and require no action to be taken by the receiving application except for closing the file descriptor passed in the event (see below).  Permission events are requests to the receiving application to decide whether permission for a file access shall be granted.  For these events, the recipient must write a response which decides whether access is granted or not.
fr: Deux types d’événements sont créés : les événements de I<notification> et les événements de I<permission>. Les événements de notification sont surtout informatifs et ne nécessitent pas d’action à prendre par l’action qui les reçoit à part pour la fermeture du descripteur de fichier passé dans l’événement (voir ci-dessous). Les événements de permission sont des demandes à l’application qui les reçoit pour décider si les droits d’accès à un fichier doivent être attribués. Pour ces événements, le destinataire doit écrire une réponse qui décide d’attribuer l’accès ou non.

note: type: Plain text
en: After a successful B<read>(2), the read buffer contains one or more of the following structures:
fr: Après une lecture (avec B<read>(2)) réussie, le tampon de lecture contient une ou plusieurs des structures suivantes :

note: type: Plain text
en: This is the length of the data for the current event and the offset to the next event in the buffer.  In the current implementation, the value of I<event_len> is always B<FAN_EVENT_METADATA_LEN>.  However, the API is designed to allow variable-length structures to be returned in the future.
fr: C’est la taille des données pour l’événement actuel et la position du prochain événement dans le tampon. Dans l’implémentation actuelle, la valeur d’I<event_len> est toujours B<FAN_EVENT_METADATA_LEN>. Cependant, l’interface de programmation est conçue pour permettre de renvoyer des structures de taille variable à l’avenir.

note: type: Plain text
en: This is an open file descriptor for the object being accessed, or B<FAN_NOFD> if a queue overflow occurred.  The file descriptor can be used to access the contents of the monitored file or directory.  The reading application is responsible for closing this file descriptor.
fr: C’est un descripteur de fichier ouvert pour l’objet actuellement accédé ou B<FAN_NOFD> si un dépassement de file est survenu. Le descripteur de fichier peut être utilisé pour accéder au contenu du fichier ou répertoire surveillé. L’application qui lit est responsable de la fermeture de ce descripteur de fichier.

note: type: Plain text
en: The following output was recorded while editing the file I</home/user/temp/notes>.  Before the file was opened, a B<FAN_OPEN_PERM> event occurred.  After the file was closed, a B<FAN_CLOSE_WRITE> event occurred.  Execution of the program ends when the user presses the ENTER key.
fr: La sortie suivante a été enregistrée lors de la modification du fichier I</home/utilisateur/temp/notes>. Avant d’ouvrir le fichier, un événement B<FAN_OPEN_PERM> est survenu. Après la fermeture du fichier, un événement B<FAN_CLOSE_WRITE> est survenu. L’exécution du programme se termine quand l’utilisateur appuie sur la touche Entrée.

note: type: SS
en: Example output
fr: Exemple de sortie

note: type: Plain text
en: # ./fanotify_example /home
    Press enter key to terminate.
    Listening for events.
    FAN_OPEN_PERM: File /home/user/temp/notes
    FAN_CLOSE_WRITE: File /home/user/temp/notes
fr: # ./fanotify_exemple /home
    Appuyer sur la touche Entrée pour quitter.
    En écoute d’événements.
    FAN_OPEN_PERM : Fichier /home/utilisateur/temp/notes
    FAN_CLOSE_WRITE : Fichier /home/utilisateur/temp/notes

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

note: type: Plain text
en: /* Read all available fanotify events from the file descriptor 'fd' */
fr: /* Lire tous les événements fanotify disponibles à partir du descripteur
       de fichier « fd » */

note: type: Plain text
en:                 path[path_len] = '\e0';
                    printf("File %s\en", path);
fr:                 path[path_len] = '\e0';
                    printf("Fichier %s\en", path);

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