So verwenden Sie die inotify-API in der Sprache C

Inotify ist eine Linux-API, die für die Überwachung von Dateisystemereignissen verwendet wird.

Dieser Artikel zeigt Ihnen, wie Inotify verwendet wird, um das Erstellen, Löschen oder Ändern von Dateien und Verzeichnissen des Linux-Dateisystems zu verfolgen.

Gehen Sie folgendermaßen vor, um eine bestimmte Datei oder ein bestimmtes Verzeichnis mit Inotify zu überwachen:

Erstellen Sie eine inotify-Instanz mit dem inotify_init()
Fügen Sie den vollständigen Pfad des zu überwachenden Verzeichnisses oder der zu überwachenden Datei und der zu überwachenden Ereignisse mit der Funktion hinzu inotify_add_watch(). In derselben Funktion legen wir fest, welche Ereignisse (ON CREATE, ON ACCESS, ON MODIFY usw.).), Änderungen an den Dateien oder Änderungen am Verzeichnis müssen überwacht werden.
Warten Sie, bis Ereignisse auftreten, und lesen Sie den Puffer, der ein oder mehrere aufgetretene Ereignisse enthält, mithilfe der lesen() oder wählen()
Verarbeiten Sie das aufgetretene Ereignis, kehren Sie dann zu Schritt 3 zurück, um auf weitere Ereignisse zu warten, und wiederholen Sie den Vorgang.
Entfernen Sie den Uhrendeskriptor mithilfe der innotify_rm_watch()
Schließen Sie die innotify-Instanz.

Jetzt sehen wir die Funktionen, die für die Inotify-API verwendet werden.

Header-Datei: sys/notify.ha

inotify_init() Funktion:

Syntax: int inotify_init (void)

Argumente: Keine Argumente.

Rückgabewerte: Bei Erfolg gibt die Funktion einen neuen Dateideskriptor zurück, bei einem Fehler gibt die Funktion -1 . zurück.

inotify_add_watch() Funktion:

Syntax: int inotify_add_watch ( int fd, const char *pathname, uint32_t mask )

Argumente:

Diese Funktion benötigt drei Argumente.

Die 1^st argument (fd) ist ein Dateideskriptor, der auf die inotify-Instanz verweist (Rückgabewert von inotify_init() Funktion) .

Die 2^nd Argument ist der Pfad des Verzeichnisses oder der Datei, die überwacht wird.

Die 3^rd Argument ist eine Bitmaske. Die Bitmaske stellt die Ereignisse dar, die beobachtet werden. Wir können ein oder mehrere Ereignisse mit bitweisem ODER ansehen.

Rückgabewerte: Bei Erfolg gibt die Funktion einen Watch-Deskriptor zurück, bei einem Fehler gibt die Funktion -1 . zurück.

innotify_rm_watch() Funktion:

Syntax: int inotify_rm_watch ( int fd, int32_t wd )

Argumente:

Diese Funktion benötigt zwei Argumente.

Die 1^st argument (fd) ist ein Dateideskriptor, der auf die inotify-Instanz verweist (Rückgabewert von inotify_init() Funktion) .

Die 2^nd argument (wd) ist ein Watch-Deskriptor (Rückgabewert von inotify_add_watch() Funktion) .

Rückgabewerte: Bei Erfolg gibt die Funktion 0 zurück, bei Misserfolg gibt die Funktion -1 . zurück.

Wir gebrauchen lesen() Funktion (deklariert in unistd.ha Header Datei), um den Puffer zu lesen, in dem die Informationen über die aufgetretenen Ereignisse in Form der innotify_event Struktur. Das innotify_event Struktur ist deklariert in sys/notify.ha Header-Datei:

struct inotify_event
int32t wd;
uint32_t Maske;
uint32_t -Cookie;
uint32_t len;
Zeichenname[];

Das innotify_event Struktur stellt ein Dateisystemereignis dar, das vom Inotify-System zurückgegeben wird, und enthält die folgenden Member:

wd: Watch-Deskriptor (Rückgabewert von inotify_add_watch() Funktion)
Maske: Eine Bitmaske, die alle Ereignistypen enthält
Plätzchen: Eindeutige Nummer, die Ereignisse identifiziert
len: Anzahl Bytes im Namensfeld
Name: Name der Datei oder des Verzeichnisses, in der das Ereignis aufgetreten ist

Unten ist ein funktionierendes Beispiel mit der Inotify-API:

Benachrichtigen.c-Datei:

#einschließen
#einschließen
#einschließen
#einschließen
#einschließen
#einschließen // Bibliothek für fcntl-Funktion

#define MAX_EVENTS 1024 /* Maximale Anzahl zu verarbeitender Ereignisse*/
#define LEN_NAME 16 /* Angenommen, die Länge des Dateinamens
wird 16 Byte nicht überschreiten*/
#define EVENT_SIZE ( sizeof (struct inotify_event) ) /*Größe eines Ereignisses*/
#define BUF_LEN ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME ))
/*Puffer zum Speichern der Daten von Ereignissen*/

int fd,wd;

void sig_handler(int sig)

/* Schritt 5. Entfernen Sie den Watch-Deskriptor und schließen Sie die Inotify-Instanz*/
inotify_rm_watch(fd, wd);
schließen(fd);
Ausgang( 0 );

int main(int argc, char **argv)

char *path_to_be_watched;
signal(SIGINT,sig_handler);

path_to_be_watched = argv[1];

/* Schritt 1. Innotify initialisieren */
fd = inotify_init();

if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
Ausgang (2);

/* Schritt 2. Uhr hinzufügen */
wd = inotify_add_watch(fd,path_to_be_watched,IN_MODIFY | IN_CREATE | IN_DELETE);

if(wd==-1)
printf("Konnte nicht ansehen : %s\n",path_to_be_watched);

sonst
printf("Beobachten : %s\n",path_to_be_watched);

während(1)

int i=0,Länge;
Zeichenpuffer[BUF_LEN];

/* Schritt 3. Puffer lesen*/
Länge = read(fd,buffer,BUF_LEN);

/* Schritt 4. Die aufgetretenen Ereignisse verarbeiten */
während ich
struct inotify_event *event = (struct inotify_event *) &buffer[i];

if(event->len)
if ( event->maske & IN_CREATE )
if ( Ereignis->Maske & IN_ISDIR )
printf( "Das Verzeichnis %s wurde erstellt.\n", Ereignis->Name );

sonst
printf( "Die Datei %s wurde erstellt.\n", Ereignis->Name );

else if ( event->mask & IN_DELETE )
if ( Ereignis->Maske & IN_ISDIR )
printf( "Das Verzeichnis %s wurde gelöscht.\n", Ereignis->Name );

sonst
printf( "Die Datei %s wurde gelöscht.\n", Ereignis->Name );

else if ( event->mask & IN_MODIFY )
if ( event->maske & IN_ISDIR )
printf( "Das Verzeichnis %s wurde geändert.\n", Ereignis->Name );

sonst
printf( "Die Datei %s wurde geändert.\n", Ereignis->Name );

i += EVENT_SIZE + event->len;

Ausgabe:

Um das Programm auszuführen und die Ausgabe zu sehen, müssen wir zuerst zwei Terminals öffnen. Ein Terminal wird verwendet, um das Programm auszuführen Benachrichtigen.c. Im zweiten Terminal gehen wir auf den Pfad, der vom Inotify überwacht wird.c. Wenn wir ein Verzeichnis oder eine Datei erstellen, eine Datei ändern oder ein Verzeichnis oder eine Datei löschen, sehen wir diese auf dem ersten Terminal.

In dem Benachrichtigen.c Beispiel, die unistd.ha Header-Datei wird für die lesen() und schließen() Funktion, die stdlib.ha Header-Datei wird für die Ausfahrt() Funktion, die Signal.ha Header-Datei wird für die Signal() Funktion und die SIG_INT Makro (Details finden Sie unter Signalbehandlung) und die fcntl.ha Header-Datei wird für die fcntl() Funktion.

Wir erklären fd (Instanz melden) und wd (Watch-Deskriptor) als globale Variablen, damit diese Variablen von allen Funktionen aus zugänglich sind.

Das fcntl() Funktion wird verwendet, damit beim Lesen mit der fd Deskriptor, der Thread wird nicht blockiert.

Als Nächstes fügen wir eine Uhr mit dem inotify_add_watch() Funktion. Hier übergeben wir fd, den Pfad des zu überwachenden Verzeichnisses und die Maske. Sie können die Maske der Ereignisse, die Sie überwachen möchten, mit bitweisem ODER übergeben.

Jetzt den Puffer lesen. Informationen zu einem oder mehreren Ereignissen werden im Puffer gespeichert. Sie können alle Ereignisse einzeln mit der Schleife bearbeiten. Sie können die Ereignis->Maske überprüfen, um zu wissen, welche Art von Ereignissen aufgetreten sind.

Wir verwenden eine unendliche while-Schleife, um kontinuierlich zu überprüfen, wann Ereignisse aufgetreten sind. Wenn keine Ereignisse aufgetreten sind, kehrt die Funktion read() mit einer 0 . zurück. Der Rückgabewert der Funktion read() wird in der Längenvariablen gespeichert. Wenn der Wert der Längenvariablen größer als Null ist, sind ein oder mehrere Ereignisse aufgetreten.

Wir benutzen das SIG_INT Signal (drücken Sie Strg+C), um den Prozess zu beenden. Wenn Sie Strg+C drücken, wird die sig_handler() Funktion wird aufgerufen (siehe Signalbehandlung für Details). Diese Funktion entfernt den Watch-Deskriptor, schließt die Inotify-Instanz fd, und beendet das Programm.

Fazit

Sie können die Inotify-API in Ihren eigenen Anwendungen zum Überwachen, Debuggen, Automatisieren und mehr auf Ihre eigene Weise verwenden. Hier haben wir den Ausführungsfluss der Inotify API gesehen.