Hvordan bruke inotify API på C -språk

Inotify er en Linux API som brukes til overvåking av filsystemhendelser.

Denne artikkelen vil vise deg hvordan Inotify brukes til å spore opprettelsen, sletting eller modifisering av filer og kataloger i Linux -filsystemet.

Følg disse trinnene for å overvåke en spesifikk fil eller katalog ved hjelp av inotify:

1. Opprett en inotify -forekomst ved å bruke inotify_init ()
2. Legg til hele banen til katalogen eller filen for å overvåke og hendelsene som skal se på med funksjonen inotify_add_watch (). I samme funksjon spesifiserer vi hvilke hendelser (på Create, på Access, på Modify etc.), endringer i filene eller endringer i katalogen må overvåkes.
3. Vent til hendelser skal oppstå og lese bufferen, som inneholder en eller flere hendelser som skjedde ved å bruke lese() eller plukke ut()
4. Behandle hendelsen som har skjedd, og gå deretter tilbake til trinn 3 for å vente på flere hendelser, og gjenta.
5. Fjern klokkebeskrivelsen ved hjelp av inotify_rm_watch ()
6. Lukk inotify -forekomsten.

Nå vil vi se funksjonene som brukes til Inotify API.

Headerfil: sys/inotify.h

inotify_init () funksjon:

Syntaks: int inotify_init (ugyldig)

Argumenter: Ingen argumenter.

Returverdier: Ved suksess returnerer funksjonen en ny filbeskrivelse, for å svikte funksjonen returnerer -1.

inotify_add_watch () funksjon:

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

Argumenter:

Denne funksjonen tar tre argumenter.

1^st Argument (FD) er en filbeskrivelse som refererer til inotify -forekomsten (returverdi av inotify_init () funksjon) .

De 2^nd Argument er banen til katalogen eller filen som overvåkes.

3^Rd Argument er en bitmaske. Bitmasken representerer hendelsene som blir overvåket. Vi kan se en eller flere hendelser ved hjelp av bitvis-eller.

Returverdier: Ved suksess returnerer funksjonen en klokkebeskrivelse, for å svikte funksjonen returnerer -1.

inotify_rm_watch () funksjon:

Syntaks: int inotify_rm_watch (int fd, int32_t wd)

Argumenter:

Denne funksjonen tar to argumenter.

1^st Argument (FD) er en filbeskrivelse som refererer til inotify -forekomsten (returverdi av inotify_init () funksjon) .

De 2^nd Argument (WD) er en klokkebeskrivelse (returverdi av inotify_add_watch () funksjon) .

Returverdier: Ved suksess returnerer funksjonen 0, for å mislykkes funksjonen returnerer -1.

Vi bruker lese() funksjon (erklært i Unistd.h Overskrift fil) for å lese bufferen, som er lagret informasjonen om hendelsene skjedde i form av inotify_event struktur. De inotify_event struktur er erklært i sys/inotify.h headerfil:

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

De inotify_event Struktur representerer en filsystemhendelse returnert av inotify -systemet og inneholder følgende medlemmer:

• wd: Se beskrivende (returverdi av inotify_add_watch () funksjon)
• maske: Litt maske som inkluderer alle hendelsestypene
• kjeks: Unikt nummer som identifiserer hendelser
• Len: Antall byte i navnefeltet
• Navn: Navn på filen eller katalogen som hendelsen skjedde

Nedenfor er et fungerende eksempel ved å bruke Inotify API:

Inotify.C -fil:

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#include // bibliotek for FCNTL -funksjon
#Define Max_Events 1024 /* Maksimalt antall hendelser for å behandle* /
#Define Len_name 16 /* Forutsatt at lengden på filnavnet
vil ikke overstige 16 byte*/
#defin Event_Size (størrelse av (struct inotify_event)) /*størrelse på en hendelse* /
#define buf_len (max_events * (Event_size + len_name))
/*buffer for å lagre dataene til hendelser*/
int fd, wd;
void sig_handler (int sig)
/* Trinn 5. Fjern klokkebeskrivelsen og lukk inotify -forekomsten*/
inotify_rm_watch (fd, wd);
Lukk (FD);
Avslutt (0);

int main (int argc, char ** argv)
char *path_to_be_watched;
signal (sigint, sig_handler);
path_to_be_watched = argv [1];
/* Trinn 1. Initialiser inotify */
fd = inotify_init ();
if (fcntl (fd, f_setfl, o_nonblock) < 0) // error checking for fcntl
Avslutt (2);
/* Steg 2. Legg til klokke */
wd = inotify_add_watch (fd, path_to_be_watched, in_modify | in_create | in_delete);
if (wd ==-1)
printf ("kunne ikke se: %s \ n", path_to_be_watched);

ellers
printf ("se: %s \ n", path_to_be_watched);

mens (1)
int i = 0, lengde;
char buffer [buf_len];
/* Trinn 3. Les buffer*/
lengde = lese (FD, buffer, buf_len);
/* Trinn 4. Behandle hendelsene som har skjedd */
mens jegstruct inotify_event *event = (struct inotify_event *) & buffer [i];
if (event-> len)
if (Event-> Mask & In_Create)
if (event-> maske & in_isdir)
printf ("Katalogen %s ble opprettet.\ n ", event-> navn);

annet
printf ("Filen %s ble opprettet.\ n ", event-> navn);


ellers hvis (Event-> Mask & In_Delete)
if (event-> maske & in_isdir)
printf ("Katalogen %s ble slettet.\ n ", event-> navn);

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


ellers hvis (Event-> Mask & In_Modify)
if (event-> maske & in_isdir)
printf ("Katalogen %s ble endret.\ n ", event-> navn);

annet
printf ("Filen %s ble endret.\ n ", event-> navn);



I + = Event_Size + Event-> Len;

Produksjon:

For å utføre programmet og se utdataene, må vi først åpne to terminaler. En terminal brukes til å kjøre programmet Inotify.c. I den andre terminalen går vi til banen som blir overvåket av Inotify.c. Hvis vi oppretter noen katalog eller fil, endrer en fil eller sletter noen katalog eller fil, vil vi se disse på den første terminalen.

I Inotify.c Eksempel, Unistd.h headerfil brukes til lese() og Lukk() funksjon, stdlib.h headerfil brukes til exit() funksjon, signal.h headerfil brukes til signal() funksjon og SIG_INT makro (se signalhåndtering for detaljer), og fcntl.h headerfil brukes til fcntl () funksjon.

Vi erklærer fd (inotify forekomst) og wd (Se beskrivende) som globale variabler slik at disse variablene er tilgjengelige fra alle funksjoner.

De fcntl () funksjon brukes slik at når vi leser ved hjelp av fd deskriptor, tråden blir ikke blokkert.

Deretter legger vi til en klokke ved hjelp av inotify_add_watch () funksjon. Her passerer vi FD, katalogens vei som vil bli sett på, og masken. Du kan passere masken til hendelsene du vil overvåke ved hjelp av bitvis-eller.

Les bufferen nå. Informasjon om en eller flere hendelser lagres i bufferen. Du kan behandle alle hendelser en etter en ved hjelp av loopen. Du kan sjekke hendelsen-> masken for å vite hvilken type hendelser som har skjedd.

Vi bruker en uendelig mens du er sløyfe for kontinuerlig å sjekke når hendelser skjedde. Hvis ingen hendelser har skjedd, returnerer leste () -funksjonen med en 0. Returverdien til lesing () -funksjonen lagres i lengdevariabelen. Når verdien av lengdevariabelen er større enn null, har en eller flere hendelser oppstått.

Vi bruker SIG_INT Signal (trykk CTRL+C) for å avslutte fra prosessen. Når du trykker på Ctrl+C, sig_handler () Funksjonen kalles (se signalhåndtering for detaljer). Denne funksjonen fjerner klokkebeskrivelsen, lukker inotify -forekomsten fd, og går ut av programmet.

Konklusjon

Du kan bruke Inotify API i dine egne applikasjoner for overvåking, feilsøking, automatisering og mer, på din egen måte. Her har vi sett utførelsesstrømmen av Inotify API.