Kako uporabljati inotify API v jeziku C

Inotify je Linux API, ki se uporablja za spremljanje dogodkov datotečnega sistema.

Ta članek vam bo pokazal, kako se Inotify uporablja za sledenje ustvarjanju, brisanju ali spreminjanju datotek in imenikov datotečnega sistema Linux.

Če želite nadzirati določeno datoteko ali imenik z uporabo funkcije Inotify, sledite tem korakom:

Ustvarite primerek inotify s pomočjo inotify_init ()
Dodajte celotno pot do imenika ali datoteke, ki jo želite spremljati, in dogodke, ki jih želite gledati s pomočjo funkcije inotify_add_watch (). V isti funkciji določimo, kateri dogodki (ON CREATE, ON ACCESS, ON MODIFY itd.), spremembe datotek ali spremembe imenika je treba spremljati.
Počakajte, da se zgodijo dogodki, in preberite vmesni pomnilnik, ki vsebuje enega ali več dogodkov, ki so se zgodili, z uporabo preberi () ali izberite ()
Obdelajte dogodek, ki se je zgodil, nato se vrnite na korak 3, da počakate na več dogodkov, in ponovite.
Odstranite deskriptor ure s pomočjo inotify_rm_watch ()
Zaprite primerek inotify.

Zdaj bomo videli funkcije, ki se uporabljajo za Inotify API.

Datoteka glave: sys / inotify.h

inotify_init () funkcija:

Sintaksa: int inotify_init (void)

Argumenti: Brez argumentov.

Vrnjene vrednosti: Ob uspehu funkcija vrne nov deskriptor datoteke, v primeru okvare pa funkcija vrne -1.

inotify_add_watch () funkcija:

Sintaksa: int inotify_add_watch (int fd, const char * ime poti, maska uint32_t)

Argumenti:

Ta funkcija ima tri argumente.

1^st argument (fd) je deskriptor datoteke, ki se nanaša na primerek inotify (vrnjena vrednost inotify_init () funkcija) .

2^nd argument je pot do imenika ali datoteke, ki se nadzira.

3^rd argument je bitna maska. Bitna maska predstavlja dogodke, ki jih spremljamo. Z bito-OR lahko spremljamo enega ali več dogodkov.

Vrnjene vrednosti: Po uspehu funkcija vrne deskriptor ure, v primeru okvare pa funkcija -1.

inotify_rm_watch () funkcija:

Sintaksa: int inotify_rm_watch (int fd, int32_t wd)

Argumenti:

Ta funkcija ima dva argumenta.

1^st argument (fd) je deskriptor datoteke, ki se nanaša na primerek inotify (vrnjena vrednost inotify_init () funkcija) .

2^nd argument (wd) je deskriptor ure (vrnjena vrednost inotify_add_watch () funkcija) .

Vrnjene vrednosti: Po uspehu funkcija vrne 0, v primeru okvare pa funkcija -1.

Uporabljamo preberi () funkcija (prijavljena v unistd.h glava datoteka) za branje medpomnilnika, v katerem so shranjeni podatki o dogodkih v obliki inotify_event struktura. The inotify_event struktura je prijavljena v sys / inotify.h datoteka glave:

struct inotify_event
int32t wd;
maska uint32_t;
uint32_t piškotek;
uint32_t len;
ime char [];

The inotify_event struktura predstavlja dogodek datotečnega sistema, ki ga vrne sistem inotify, in vsebuje naslednje člane:

wd: Watch deskriptor (vrnjena vrednost inotify_add_watch () funkcija)
masko: Bitna maska, ki vključuje vse vrste dogodkov
piškotek: Enolična številka, ki identificira dogodke
len: Število bajtov v polju z imenom
ime: Ime datoteke ali imenika, v katerem se je dogodek zgodil

Spodaj je delovni primer z uporabo API-ja Inotify:

Obvesti.c datoteka:

#include
#include
#include
#include
#include
#include // knjižnica za funkcijo fcntl

#define MAX_EVENTS 1024 / * Največje število dogodkov za obdelavo * /
#define LEN_NAME 16 / * Ob predpostavki, da je dolžina imena datoteke
ne presega 16 bajtov * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * velikost enega dogodka * /
#define BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * medpomnilnik za shranjevanje podatkov o dogodkih * /

int fd, wd;

void sig_handler (int sig)

/ * 5. korak. Odstranite deskriptor ure in zaprite primerek inotify * /
inotify_rm_watch (fd, wd);
blizu (fd);
izhod (0);

int main (int argc, char ** argv)

char * pot_do_be_ogleda;
signal (SIGINT, sig_handler);

path_to_be_watched = argv [1];

/* Korak 1. Inicializiraj inotify * /
fd = inotify_init ();

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

/ * 2. korak. Dodaj uro * /
wd = inotify_add_watch (fd, path_to_be_watched, IN_MODIFY | IN_CREATE | IN_DELETE);

če (wd == - 1)
printf ("Ne morem si ogledati:% s \ n", pot_do_be_ gledal);

sicer
printf ("Ogled:% s \ n", pot_do_be_ gledal);

medtem ko (1)

int i = 0, dolžina;
medpomnilnik znakov [BUF_LEN];

/ * Korak 3. Bralni vmesnik * /
dolžina = branje (fd, medpomnilnik, BUF_LEN);

/ * Korak 4. Obdelajte dogodke, ki so se zgodili * /
medtem ko jaz
struct inotify_event * dogodek = (struct inotify_event *) & buffer [i];

if (event-> len)
če (dogodek-> maska & IN_CREATE)
if (event-> mask & IN_ISDIR)
printf ("Imenik% s je bil ustvarjen.\ n ", dogodek-> ime);

sicer
printf ("Datoteka% s je bila ustvarjena.\ n ", dogodek-> ime);

sicer če (dogodek-> maska & IN_DELETE)
if (event-> mask & IN_ISDIR)
printf ("Imenik% s je bil izbrisan.\ n ", dogodek-> ime);

sicer
printf ("Datoteka% s je bila izbrisana.\ n ", dogodek-> ime);

sicer če (dogodek-> maska & IN_MODIFY)
if (event-> mask & IN_ISDIR)
printf ("Imenik% s je bil spremenjen.\ n ", dogodek-> ime);

sicer
printf ("Datoteka% s je bila spremenjena.\ n ", dogodek-> ime);

i + = EVENT_SIZE + dogodek-> len;

Izhod:

Za zagon programa in ogled izhoda moramo najprej odpreti dva terminala. Za zagon programa se uporablja en terminal Obvesti.c. V drugem terminalu gremo na pot, ki jo opazuje Inotify.c. Če ustvarimo kateri koli imenik ali datoteko, spremenimo katero koli datoteko ali izbrišemo kateri koli imenik ali datoteko, jih bomo videli na prvem terminalu.

V Obvesti.c na primer unistd.h datoteka glave se uporablja za datoteko preberi () in zapri () funkcija, stdlib.h datoteka glave se uporablja za datoteko izhod () funkcija, signal.h datoteka glave se uporablja za datoteko signal () funkcijo in SIG_INT makro (za podrobnosti glejte Ravnanje s signali) in fcntl.h datoteka glave se uporablja za datoteko fcntl () funkcijo.

Izjavljamo fd (izvesti primerek) in wd (watch deskriptor) kot globalne spremenljivke, tako da so te spremenljivke dostopne iz vseh funkcij.

The fcntl () funkcija se uporablja tako, da ko beremo z uporabo fd deskriptor, nit ne bo blokirana.

Nato dodamo uro z uporabo inotify_add_watch () funkcijo. Tu gremo mimo fd, poti do imenika, ki ga bomo gledali, in maske. Masko dogodkov, ki jih želite spremljati, lahko prenesete s pomočjo bit-OR.

Zdaj preberite vmesnik. Informacije o enem ali več dogodkih so shranjene v vmesnem pomnilniku. Z zanko lahko obdelate vse dogodke enega za drugim. Če želite vedeti, katera vrsta dogodkov se je zgodila, lahko preverite masko event->.

Za nenehno preverjanje, kdaj so se zgodili dogodki, uporabljamo neskončno zanko while. Če se noben dogodek ni zgodil, se funkcija read () vrne z 0. Vrnjena vrednost funkcije read () je shranjena v spremenljivki dolžine. Ko je vrednost spremenljivke dolžine večja od nič, je prišlo do enega ali več dogodkov.

Uporabljamo SIG_INT signal (pritisnite Ctrl + C) za izhod iz procesa. Ko pritisnete Ctrl + C, se tipka sig_handler () funkcija se pokliče (za podrobnosti glejte Upravljanje signala). Ta funkcija odstrani deskriptor ure in zapre primerek inotify fd, in zapre program.

Zaključek

API Inotify lahko uporabljate v svojih aplikacijah za spremljanje, odpravljanje napak, avtomatizacijo in še več, na svoj način. Tu smo videli potek izvajanja API-ja Inotify.