Comment utiliser API inotifier dans le langage C

Inotify est une API Linux utilisée pour la surveillance des événements du système de fichiers.

Cet article vous montrera comment Inotify est utilisé pour suivre la création, la suppression ou la modification des fichiers et répertoires du système de fichiers Linux.

Pour surveiller un fichier ou un répertoire spécifique en utilisant Inotify, suivez ces étapes:

1. Créer une instance inotify à l'aide du inotify_init ()
2. Ajoutez le chemin complet du répertoire ou le fichier à surveiller et les événements à regarder en utilisant la fonction inotify_add_watch (). Dans la même fonction, nous spécifions quels événements (sur Créer, sur l'accès, sur modifier etc.), les modifications des fichiers ou les modifications du répertoire doivent être surveillées.
3. Attendez que les événements se produisent et lisent le tampon, qui contient un ou plusieurs événements qui se sont produits, en utilisant le lire() ou sélectionner()
4. Traiter l'événement qui s'est produit, puis revenir à l'étape 3 pour attendre plus d'événements et répéter.
5. Supprimer le descripteur de montre à l'aide du inotify_rm_watch ()
6. Fermez l'instance Inotify.

Maintenant, nous verrons les fonctions qui sont utilisées pour inotifier l'API.

En tête de fichier: sys / inotify.H

inotify_init () fonction :

Syntaxe: int inotify_init (void)

Arguments: pas d'arguments.

Valeurs de retour: sur le succès, la fonction renvoie un nouveau descripteur de fichier, pour l'échec de la fonction renvoie -1.

inotify_add_watch () fonction:

Syntaxe: int inotify_add_watch (int fd, const char * pathname, uint32_t masque)

Arguments:

Cette fonction prend trois arguments.

Le 1^St L'argument (FD) est un descripteur de fichiers qui se réfère à l'instance Inotify (valeur de retour de inotify_init () fonction) .

Les deux^nd L'argument est le chemin du répertoire ou du fichier qui est surveillé.

Le 3^rd L'argument est un massacre. Le massask représente les événements qui sont surveillés. Nous pouvons regarder un ou plusieurs événements en utilisant.

Valeurs de retour: Au cours du succès, la fonction renvoie un descripteur de montre, pour l'échec de la fonction renvoie -1.

inotify_rm_watch () fonction:

Syntaxe: int inotify_rm_watch (int fd, int32_t wd)

Arguments:

Cette fonction prend deux arguments.

Le 1^St L'argument (FD) est un descripteur de fichiers qui se réfère à l'instance Inotify (valeur de retour de inotify_init () fonction) .

Les deux^nd L'argument (wd) est un descripteur de montre (valeur de retour de inotify_add_watch () fonction) .

Valeurs de retour: Sur le succès, la fonction renvoie 0, pour l'échec la fonction renvoie -1.

Nous utilisons lire() fonction (déclaré dans unistd.H entête fichier) Pour lire le tampon, qui est stocké, les informations des événements se sont produites sous la forme du inotify_event structure. Le inotify_event la structure est déclarée dans sys / inotify.H En tête de fichier:

struct inotify_event
INT32T WD;
Masque Uint32_T;
cookie uint32_t;
uint32_t len;
Nom char [];

Le inotify_event La structure représente un événement de système de fichiers renvoyé par le système Inotify et contient les membres suivants:

• wd: Regarder le descripteur (valeur de retour de inotify_add_watch () fonction)
• masque: Un peu de masque qui comprend tous les types d'événements
• biscuit: Numéro unique qui identifie les événements
• Len: Nombre d'octets dans le champ Nom
• nom: Nom du fichier ou du répertoire dans lequel l'événement s'est produit

Vous trouverez ci-dessous un exemple de travail, en utilisant l'API Inotify:

Inotifier.Fichier C:

#inclure
#inclure
#inclure
#inclure
#inclure
#include // bibliothèque pour la fonction fcntl
#define max_events 1024 / * Nombre maximum d'événements à traiter * /
#define Len_name 16 / * en supposant que la longueur du nom de fichier
ne dépassera pas 16 octets * /
#define event_size (sizeof (struct inotify_event)) / * taille d'un événement * /
#define buf_len (max_events * (event_size + len_name)))
/ * tampon pour stocker les données des événements * /
int fd, wd;
void sig_handler (int sig)
/ * Étape 5. Supprimez le descripteur de montre et fermez l'instance Inotify * /
inotify_rm_watch (fd, wd);
Close (FD);
sortie (0);

int main (int argc, char ** argv)
char * path_to_be_watched;
Signal (Sigint, Sig_Handler);
path_to_be_watched = argv [1];
/* Étape 1. Initialiser l'inotifie * /
fd = inotify_init ();
if (fcntl (fd, f_setfl, o_nonblock) < 0) // error checking for fcntl
sortie (2);
/* Étape 2. Ajouter une montre * /
wd = inotify_add_watch (fd, path_to_be_watched, in_modify | in_create | in_delete);
if (wd == - 1)
printf ("Impossible de regarder:% s \ n", path_to_be_watched);

autre
printf ("Watching:% s \ n", path_to_be_watched);

tandis que (1)
int i = 0, longueur;
tampon char [buf_len];
/* Étape 3. Lire le tampon * /
length = read (fd, tampon, buf_len);
/* Étape 4. Traiter les événements qui se sont produits * /
alors que jestruct inotify_event * event = (struct inotify_event *) & buffer [i];
if (event-> len)
if (event-> mask & in_create)
if (event-> mask & in_isdir)
printf ("Le répertoire% S a été créé.\ n ", événement-> name);

autre
printf ("Le fichier% s a été créé.\ n ", événement-> name);


else if (event-> mask & in_delete)
if (event-> mask & in_isdir)
printf ("Le répertoire% s a été supprimé.\ n ", événement-> name);

autre
printf ("Le fichier% s a été supprimé.\ n ", événement-> name);


else if (event-> mask & in_modify)
if (event-> mask & in_isdir)
printf ("Le répertoire% s a été modifié.\ n ", événement-> name);

autre
printf ("Le fichier% s a été modifié.\ n ", événement-> name);



i + = event_size + event-> len;

Sortir:

Pour exécuter le programme et voir la sortie, nous devons d'abord ouvrir deux terminaux. Un terminal est utilisé pour exécuter le programme Inotifier.c. Dans le deuxième terminal, nous allons sur le chemin qui est surveillé par l'inotifier.c. Si nous créons un répertoire ou un fichier, modifier un fichier ou supprimer un répertoire ou un fichier, nous les verrons sur le premier terminal.

Dans le Inotifier.c exemple, le unistd.H Le fichier d'en-tête est utilisé pour le lire() et fermer() fonction, le stdlib.H Le fichier d'en-tête est utilisé pour le sortie() fonction, le signal.H Le fichier d'en-tête est utilisé pour le signal() fonction et le Sig_int macro (voir la manipulation du signal pour plus de détails) et le fcntl.H Le fichier d'en-tête est utilisé pour le fcntl () fonction.

Nous déclarons FD (inotifier l'instance) et wd (regarder le descripteur) en tant que variables globales afin que ces variables soient accessibles à partir de toutes les fonctions.

Le fcntl () La fonction est utilisée de sorte que lorsque nous lisons en utilisant le FD Descripteur, le thread ne sera pas bloqué.

Ensuite, nous ajoutons une montre en utilisant le inotify_add_watch () fonction. Ici, nous passons FD, le chemin du répertoire qui sera surveillé et le masque. Vous pouvez transmettre le masque des événements que vous souhaitez surveiller.

Maintenant, lisez le tampon. Des informations sur un ou plusieurs événements sont stockées dans le tampon. Vous pouvez traiter tous les événements un par un en utilisant la boucle. Vous pouvez vérifier l'événement-> Masque pour savoir quel type d'événements s'est produit.

Nous utilisons une boucle infinie pour vérifier en continu lorsque les événements se sont produits. Si aucun événement n'a eu lieu, la fonction Read () revient avec un 0. La valeur de retour de la fonction read () est stockée dans la variable de longueur. Lorsque la valeur de la variable de longueur est supérieure à zéro, un ou plusieurs événements se sont produits.

Nous utilisons le Sig_int Signal (appuyez sur Ctrl + C) pour quitter le processus. Lorsque vous appuyez sur Ctrl + C, le sig_handler () La fonction est appelée (voir la manipulation du signal pour plus de détails). Cette fonction supprime le descripteur de montre, ferme l'instance inotify FD, et sort du programme.

Conclusion

Vous pouvez utiliser API inotify dans vos applications pour la surveillance, le débogage, l'automatisation, etc. Ici, nous avons vu le flux d'exécution de l'API inotifier.