Hoe inotify API te gebruiken in C Language

Inotify is een Linux API die wordt gebruikt voor het bewaken van bestandssysteemgebeurtenissen.

Dit artikel laat u zien hoe Inotify wordt gebruikt voor het volgen van het maken, verwijderen of wijzigen van bestanden en mappen van het Linux-bestandssysteem.

Volg deze stappen om een specifiek bestand of map te controleren met Inotify:

Maak een inotify-instantie met behulp van de inotify_init()
Voeg het volledige pad toe van de map of het bestand dat moet worden gecontroleerd en de te bekijken gebeurtenissen met behulp van de functie inotify_add_watch(). In dezelfde functie specificeren we welke evenementen (ON CREATE, ON ACCESS, ON MODIFY etc.), moeten wijzigingen in de bestanden of wijzigingen in de directory worden gecontroleerd.
Wacht tot gebeurtenissen plaatsvinden en lees de buffer, die een of meer gebeurtenissen bevat die zich hebben voorgedaan, met behulp van de lezen() of selecteer()
Verwerk de gebeurtenis die heeft plaatsgevonden, keer terug naar stap 3 om op meer gebeurtenissen te wachten en herhaal.
Verwijder de horlogedescriptor met de inotify_rm_watch()
Sluit de inotify-instantie.

Nu zullen we de functies zien die worden gebruikt voor Inotify API.

Header-bestand: sys/inotify.h

inotify_init() functie:

Syntaxis: int inotify_init (void)

Argumenten: Geen argumenten.

Retourwaarden: Bij succes retourneert de functie een nieuwe bestandsdescriptor, bij een fout retourneert de functie -1.

inotify_add_watch() functie:

Syntaxis: int inotify_add_watch ( int fd, const char * padnaam, uint32_t mask )

Argumenten:

Deze functie heeft drie argumenten:.

de 1^st argument (fd) is een bestandsdescriptor die verwijst naar de inotify-instantie (retourwaarde van inotify_init() functie) .

De 2^nd argument is het pad van de map of het bestand dat wordt gecontroleerd.

de 3^rd argument is een bitmasker. Het bitmasker vertegenwoordigt de gebeurtenissen die worden bekeken. We kunnen een of meer evenementen bekijken met bitwise-OR.

Retourwaarden: Bij succes retourneert de functie een watch-descriptor, bij falen retourneert de functie -1.

inotify_rm_watch() functie:

Syntaxis: int inotify_rm_watch ( int fd, int32_t wd )

Argumenten:

Deze functie heeft twee argumenten:.

de 1^st argument (fd) is een bestandsdescriptor die verwijst naar de inotify-instantie (retourwaarde van inotify_init() functie) .

De 2^nd argument (wd) is een watch-descriptor (retourwaarde van inotify_add_watch() functie) .

Retourwaarden: Bij succes retourneert de functie 0, voor mislukking retourneert de functie -1.

We gebruiken lezen() functie (verklaard in unistd.h koptekst bestand) om de buffer te lezen, waarin de informatie over de gebeurtenissen is opgeslagen in de vorm van de inotify_event structuur. De inotify_event structuur wordt gedeclareerd in sys/inotify.h header-bestand:

struct inotify_event
int32t wd;
uint32_t masker;
uint32_t cookie;
uint32_t len;
char naam[];

De inotify_event structuur vertegenwoordigt een bestandssysteemgebeurtenis die wordt geretourneerd door het inotify-systeem en bevat de volgende leden:

wd: Bekijk descriptor (retourwaarde van inotify_add_watch() functie)
masker: Een bitmasker dat alle gebeurtenistypen bevat
koekje: Uniek nummer dat gebeurtenissen identificeert
len: Aantal bytes in het naamveld
naam: Naam van het bestand of de map waarin de gebeurtenis plaatsvond

Hieronder is een werkend voorbeeld, met behulp van de Inotify API:

inlichten.c-bestand:

#include
#include
#include
#include
#include
#include // bibliotheek voor fcntl-functie

#define MAX_EVENTS 1024 /* Maximum aantal te verwerken gebeurtenissen*/
#define LEN_NAME 16 /* Ervan uitgaande dat de lengte van de bestandsnaam
zal niet groter zijn dan 16 bytes*/
#define EVENT_SIZE ( sizeof (struct inotify_event) ) /*grootte van één evenement*/
#define BUF_LEN ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME ))
/*buffer om de gegevens van gebeurtenissen op te slaan*/

int fd,wd;

void sig_handler(int sig)

/* Stap 5. Verwijder de watch-descriptor en sluit de inotify-instantie*/
inotify_rm_watch (fd, wd);
sluiten (fd);
uitgang( 0 );

int main(int argc, char **argv)

char *path_to_be_watched;
signaal (SIGINT, sig_handler);

path_to_be_watched = argv[1];

/* Stap 1. Inotify initialiseren */
fd = inotify_init();

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

/* Stap 2. Horloge toevoegen */
wd = inotify_add_watch(fd,path_to_be_watched,IN_MODIFY | IN_CREATE | IN_DELETE);

if(wd==-1)
printf("Kon niet kijken: %s\n",path_to_be_watched);

anders
printf("Bekijken: %s\n",path_to_be_watched);

terwijl(1)

int i=0,lengte;
char buffer [BUF_LEN];

/* Stap 3. Leesbuffer*/
lengte = lezen (fd,buffer,BUF_LEN);

/* Stap 4. Verwerk de gebeurtenissen die hebben plaatsgevonden */
terwijl ik
struct inotify_event *event = (struct inotify_event *) &buffer[i];

if(gebeurtenis->len)
if ( gebeurtenis-> masker & IN_CREATE )
if ( gebeurtenis-> masker & IN_ISDIR )
printf( "De map %s is aangemaakt.\n", gebeurtenis->naam );

anders
printf( "Het bestand %s is aangemaakt.\n", gebeurtenis->naam );

else if ( event-> mask & IN_DELETE )
if ( gebeurtenis-> masker & IN_ISDIR )
printf( "De map %s is verwijderd.\n", gebeurtenis->naam );

anders
printf( "Het bestand %s is verwijderd.\n", gebeurtenis->naam );

else if ( event-> mask & IN_MODIFY )
if ( gebeurtenis-> masker & IN_ISDIR )
printf( "De map %s is gewijzigd.\n", gebeurtenis->naam );

anders
printf( "Het bestand %s is gewijzigd.\n", gebeurtenis->naam );

i += EVENT_SIZE + gebeurtenis->len;

Uitgang:

Om het programma uit te voeren en de uitvoer te zien, moeten we eerst twee terminals openen. Eén terminal wordt gebruikt om het programma uit te voeren aankondigen.c. In de tweede terminal gaan we naar het pad dat wordt bekeken door de Inotify.c. Als we een map of bestand maken, een bestand wijzigen of een map of bestand verwijderen, zien we deze op de eerste terminal.

In de aankondigen.c voorbeeld, de unistd.h header-bestand wordt gebruikt voor de lezen() en dichtbij() functie, de stdlib.h header-bestand wordt gebruikt voor de Uitgang() functie, de signaal.h header-bestand wordt gebruikt voor de signaal() functie en de SIG_INT macro (Zie signaalverwerking voor details), en de fcntl.h header-bestand wordt gebruikt voor de fcntl() functie.

Wij verklaren fd (intify instantie) en wd (bekijk descriptor) als globale variabelen zodat deze variabelen toegankelijk zijn vanuit alle functies.

De fcntl() functie wordt gebruikt zodat wanneer we lezen met behulp van de fd descriptor, de thread wordt niet geblokkeerd.

Vervolgens voegen we een horloge toe met de inotify_add_watch() functie. Hier geven we fd door, het pad van de map die zal worden bekeken, en het masker. U kunt het masker doorgeven van de gebeurtenissen die u wilt controleren met bitwise-OF.

Lees nu de buffer. Informatie over een of meer gebeurtenissen wordt opgeslagen in de buffer. U kunt alle gebeurtenissen één voor één verwerken met behulp van de lus. U kunt het evenement -> masker controleren om te weten welk type evenement is gebeurd.

We gebruiken een oneindige while-lus om continu te controleren wanneer gebeurtenissen plaatsvonden. Als er geen gebeurtenissen hebben plaatsgevonden, retourneert de functie read() met een 0. De retourwaarde van de functie read() wordt opgeslagen in de lengtevariabele. Wanneer de waarde van de lengtevariabele groter is dan nul, hebben zich een of meer gebeurtenissen voorgedaan.

Wij gebruiken de SIG_INT signaal (druk op Ctrl+C) om het proces te verlaten. Wanneer u op Ctrl+C drukt, wordt de sig_handler() functie wordt aangeroepen (zie signaalverwerking voor details). Deze functie verwijdert de watch-descriptor, sluit de inotify-instantie fd, en verlaat het programma.

Conclusie

U kunt de Inotify API op uw eigen manier in uw eigen applicaties gebruiken voor monitoring, debugging, automatisering en meer. Hier hebben we de uitvoeringsstroom van Inotify API gezien.