Hvordan bruke inotify API på C-språk

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

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

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

Opprett en inotify-forekomst ved hjelp av inotify_init ()
Legg til hele banen til katalogen eller filen du skal overvåke, og hendelsene du vil se ved hjelp av funksjonen inotify_add_watch (). I samme funksjon spesifiserer vi hvilke hendelser (PÅ OPPRETT, PÅ TILGANG, PÅ MODIFISERING osv.), endringer i filene eller endringer i katalogen må overvåkes.
Vent til hendelser skjer og les bufferen, som inneholder en eller flere hendelser som har skjedd, ved hjelp av lese() eller å velge()
Behandle hendelsen som har skjedd, og gå deretter tilbake til trinn 3 for å vente på flere hendelser, og gjenta.
Fjern klokkebeskrivelsen ved hjelp av inotify_rm_watch ()
Lukk inotify-forekomsten.

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

Topptekstfil: sys / inotify.h

inotify_init () funksjon:

Syntaks: int inotify_init (ugyldig)

Argumenter: Ingen argumenter.

Returverdier: Når det lykkes, returnerer funksjonen en ny filbeskrivelse, for feil returnerer funksjonen -1.

inotify_add_watch () funksjon:

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

Argumenter:

Denne funksjonen tar tre argumenter.

Den 1^St argument (fd) er en filbeskrivelse som refererer til inotify-forekomsten (returverdien av inotify_init () funksjon) .

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

3^rd argument er en bitmaske. Bitmasken representerer hendelsene som blir sett på. Vi kan se en eller flere hendelser ved hjelp av bitwise-OR.

Returverdier: Når det lykkes, returnerer funksjonen en klokkebeskrivelse, for feil returnerer funksjonen -1.

inotify_rm_watch () funksjon:

Syntaks: int inotify_rm_watch (int fd, int32_t wd)

Argumenter:

Denne funksjonen tar to argumenter.

Den 1^St argument (fd) er en filbeskrivelse som refererer til inotify-forekomsten (returverdien av inotify_init () funksjon) .

2^nd argument (wd) er en klokkebeskrivelse (returverdi på inotify_add_watch () funksjon) .

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

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

struct inotify_event
int32t wd;
uint32_t maske;
uint32_t informasjonskapsel;
uint32_t len;
røye navn [];

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

wd: Watch descriptor (returverdi på inotify_add_watch () funksjon)
maske: En liten maske som inkluderer alle arrangementstypene
kjeks: Unikt nummer som identifiserer hendelser
len: Antall byte i navnefeltet
Navn: Navnet på filen eller katalogen der hendelsen skjedde

Nedenfor er et fungerende eksempel ved bruk av Inotify API:

Inotify.c-fil:

#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere // bibliotek for fcntl-funksjon

#define MAX_EVENTS 1024 / * Maksimalt antall hendelser som skal behandles * /
#define LEN_NAME 16 / * Forutsatt at lengden på filnavnet
vil ikke overstige 16 byte * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * størrelse på en hendelse * /
#define BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * buffer for å lagre data om hendelser * /

int fd, wd;

ugyldig sig_handler (int sig)

/ * Trinn 5. Fjern klokkebeskrivelsen og lukk inotify-forekomsten * /
inotify_rm_watch (fd, wd);
lukk (fd);
exit (0);

int main (int argc, char ** argv)

char * path_to_be_watch;
signal (SIGINT, sig_handler);

path_to_be_watched = argv [1];

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

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

/* Steg 2. Legg til klokke * /
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);

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

mens (1)

int i = 0, lengde;
røyebuffer [BUF_LEN];

/ * Trinn 3. Les buffer * /
lengde = lese (fd, buffer, BUF_LEN);

/ * Trinn 4. Behandle hendelsene som har skjedd * /
mens jeg
struct inotify_event * event = (struct inotify_event *) & buffer [i];

hvis (event-> len)
hvis (event-> maske & IN_CREATE)
hvis (event-> maske og IN_ISDIR)
printf ("Katalogen% s ble opprettet.\ n ", event-> navn);

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

annet hvis (event-> maske & IN_DELETE)
hvis (event-> maske og IN_ISDIR)
printf ("Katalogen% s ble slettet.\ n ", event-> navn);

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

annet hvis (event-> maske & IN_MODIFY)
hvis (event-> maske og 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. Én terminal brukes til å kjøre programmet Inotify.c. I den andre terminalen går vi til stien som blir fulgt av Inotify.c. Hvis vi oppretter en katalog eller fil, endrer hvilken som helst fil eller sletter en katalog eller fil, vil vi se disse på den første terminalen.

I Inotify.c eksempel unistd.h header-fil brukes til lese() og Lukk() funksjon, stdlib.h header-fil brukes til exit() funksjon, signal.h header-fil brukes til signal() funksjon og SIG_INT makro (Se signalhåndtering for detaljer), og fcntl.h header-fil brukes til fcntl () funksjon.

Vi erklærer fd (inotify instans) og wd (se deskriptor) som globale variabler slik at disse variablene er tilgjengelige fra alle funksjoner.

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

Deretter legger vi til en klokke ved hjelp av inotify_add_watch () funksjon. Her passerer vi fd, banen til katalogen som skal overvåkes, og masken. Du kan sende masken til hendelsene du vil overvåke, ved hjelp av bitvis-ELLER.

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

Vi bruker en uendelig mens loop for kontinuerlig å sjekke når hendelser skjedde. Hvis ingen hendelser har skjedd, returnerer read () -funksjonen med 0. Returverdien til read () - funksjonen er lagret i lengdevariabelen. Når verdien av lengdevariabelen er større enn null, har en eller flere hendelser skjedd.

Vi bruker SIG_INT signal (trykk Ctrl + C) for å avslutte prosessen. Når du trykker på Ctrl + C, vises sig_handler () funksjon kalles (Se signalhåndtering for detaljer). Denne funksjonen fjerner klokkebeskrivelsen, lukker inotify-forekomsten fd, og avslutter 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ørelsesflyten av Inotify API.