Sådan bruges inotify API på C-sprog

Inotify er en Linux API, der bruges til overvågning af filsystemhændelser.

Denne artikel viser dig, hvordan Inotify bruges til at spore oprettelse, sletning eller ændring af filer og kataloger til Linux-filsystemet.

Følg disse trin for at overvåge en bestemt fil eller mappe ved hjælp af Inotify:

Opret en inotify-forekomst ved hjælp af inotify_init ()
Tilføj den fulde sti til biblioteket eller filen, der skal overvåges, og de begivenheder, der skal ses ved hjælp af funktionen inotify_add_watch (). I den samme funktion specificerer vi hvilke begivenheder (PÅ OPRET, PÅ ADGANG, PÅ ÆNDRING osv.), ændringer af filerne eller ændringer i biblioteket skal overvåges.
Vent på, at begivenheder skal forekomme, og læs bufferen, som indeholder en eller flere begivenheder, der opstod ved hjælp af Læs() eller Vælg()
Behandl den begivenhed, der har fundet sted, vend derefter tilbage til trin 3 for at vente på flere begivenheder og gentag.
Fjern urbeskrivelsen ved hjælp af inotify_rm_watch ()
Luk inotify-forekomsten.

Nu vil vi se de funktioner, der bruges til Inotify API.

Overskriftsfil: sys / inotify.h

inotify_init () funktion:

Syntaks: int inotify_init (ugyldigt)

Argumenter: Ingen argumenter.

Returværdier: Efter succes returnerer funktionen en ny filbeskrivelse, hvis funktionen returnerer -1.

inotify_add_watch () fungere:

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

Argumenter:

Denne funktion tager tre argumenter.

Den 1^St argument (fd) er en filbeskrivelse, der refererer til inotify-forekomsten (returværdien af inotify_init () fungere) .

Den 2^nd argument er stien til den mappe eller fil, der overvåges.

Den 3^rd argument er en bitmaske. Bitmask repræsenterer de begivenheder, der overvåges. Vi kan se en eller flere begivenheder ved hjælp af bitwise-OR.

Returneringsværdier: Efter succes returnerer funktionen en urbeskrivelse, hvis funktionen returnerer -1.

inotify_rm_watch () fungere:

Syntaks: int inotify_rm_watch (int fd, int32_t wd)

Argumenter:

Denne funktion tager to argumenter.

Den 1^St argument (fd) er en filbeskrivelse, der refererer til inotify-forekomsten (returværdien af inotify_init () fungere) .

Den 2^nd argument (wd) er en urbeskrivelse (returværdi på inotify_add_watch () fungere) .

Returneringsværdier: Ved succes returnerer funktionen 0, for fejl returnerer funktionen -1.

Vi bruger Læs() funktion (erklæret i unistd.h header fil) for at læse bufferen, som er gemt, informationen om de begivenheder, der opstod i form af inotify_event struktur. Det inotify_event struktur er erklæret i sys / inotify.h header-fil:

struct inotify_event
int32t wd;
uint32_t maske;
uint32_t cookie;
uint32_t len;
char navn [];

Det inotify_event struktur repræsenterer en filsystemhændelse returneret af inotify-systemet og indeholder følgende medlemmer:

wd: Urbeskrivelse (returværdi på inotify_add_watch () fungere)
maske: En lille maske, der inkluderer alle begivenhedstyper
cookie: Entydigt nummer, der identificerer begivenheder
len: Antal byte i navnefeltet
navn: Navnet på filen eller biblioteket, hvor begivenheden opstod

Nedenfor er et fungerende eksempel ved hjælp af Inotify API:

Inotify.c-fil:

#omfatte
#omfatte
#omfatte
#omfatte
#omfatte
#omfatte // bibliotek til fcntl-funktion

#define MAX_EVENTS 1024 / * Maksimalt antal begivenheder, der skal behandles * /
#define LEN_NAME 16 / * Forudsat at længden af filnavnet
overstiger ikke 16 byte * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * størrelse på en begivenhed * /
#definer BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * buffer til at gemme data om begivenheder * /

int fd, wd;

ugyldig sig_handler (int sig)

/ * Trin 5. Fjern urbeskrivelsen, og luk inotify-forekomsten * /
inotify_rm_watch (fd, wd);
luk (fd);
exit (0);

int main (int argc, char ** argv)

char * path_to_be_watch;
signal (SIGINT, sig_handler);

path_to_be_watched = argv [1];

/* Trin 1. Initialiser inotify * /
fd = inotify_init ();

hvis (fcntl (fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
udgang (2);

/ * Trin 2. Tilføj ur * /
wd = inotify_add_watch (fd, path_to_be_watch, IN_MODIFY | IN_CREATE | IN_DELETE);

hvis (wd == - 1)
printf ("Kunne ikke se:% s \ n", path_to_be_watched);

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

mens (1)

int i = 0, længde;
char buffer [BUF_LEN];

/ * Trin 3. Læs buffer * /
længde = læs (fd, buffer, BUF_LEN);

/ * Trin 4. Behandle de begivenheder, der har fundet sted * /
mens jeg
struct inotify_event * event = (struct inotify_event *) & buffer [i];

hvis (event-> len)
hvis (event-> maske & IN_CREATE)
hvis (begivenhed-> maske & IN_ISDIR)
printf ("Mappen% s blev oprettet.\ n ", event-> navn);

andet
printf ("Filen% s blev oprettet.\ n ", event-> navn);

ellers hvis (event-> maske & IN_DELETE)
hvis (begivenhed-> maske & IN_ISDIR)
printf ("Mappen% s blev slettet.\ n ", event-> navn);

andet
printf ("Filen% s blev slettet.\ n ", event-> navn);

ellers hvis (event-> maske & IN_MODIFY)
hvis (begivenhed-> maske & IN_ISDIR)
printf ("Mappen% s blev ændret.\ n ", event-> navn);

andet
printf ("Filen% s blev ændret.\ n ", event-> navn);

i + = EVENT_SIZE + begivenhed-> len;

Produktion:

For at udføre programmet og se output skal vi først åbne to terminaler. En terminal bruges til at køre programmet Inotify.c. I den anden terminal går vi til den sti, som Inotify overvåger.c. Hvis vi opretter en mappe eller fil, ændrer en fil eller sletter en mappe eller fil, vil vi se disse på den første terminal.

I Inotify.c f.eks unistd.h header-fil bruges til Læs() og tæt() funktion, den stdlib.h header-fil bruges til Afslut() funktion, den signal.h header-fil bruges til signal() funktion og SIG_INT makro (Se signalhåndtering for detaljer), og fcntl.h header-fil bruges til fcntl () fungere.

Vi erklærer fd (inotify instans) og wd (watch descriptor) som globale variabler, så disse variabler er tilgængelige fra alle funktioner.

Det fcntl () funktionen bruges, så når vi læser ved hjælp af fd deskriptor, vil tråden ikke blive blokeret.

Dernæst tilføjer vi et ur ved hjælp af inotify_add_watch () fungere. Her passerer vi fd, stien til den mappe, der skal overvåges, og masken. Du kan videregive masken for de begivenheder, du vil overvåge, ved hjælp af bitvis-ELLER.

Læs nu bufferen. Oplysninger om en eller flere begivenheder gemmes i bufferen. Du kan behandle alle begivenheder en efter en ved hjælp af loop. Du kan kontrollere begivenheds-> masken for at vide, hvilken type begivenheder der er sket.

Vi bruger en uendelig mens løkke til kontinuerligt at kontrollere, hvornår begivenheder opstod. Hvis der ikke er sket nogen hændelser, vender funktionen read () tilbage med et 0. Returværdien for funktionen read () er gemt i længdevariablen. Når værdien af længdevariablen er større end nul, er der sket en eller flere begivenheder.

Vi bruger SIG_INT signal (tryk på Ctrl + C) for at afslutte processen. Når du trykker på Ctrl + C, vises sig_handler () funktion kaldes (Se signalhåndtering for detaljer). Denne funktion fjerner urbeskriveren, lukker inotify-forekomsten fd, og afslutter programmet.

Konklusion

Du kan bruge Inotify API i dine egne applikationer til overvågning, fejlretning, automatisering og mere på din egen måde. Her har vi set udførelsesstrømmen af Inotify API.