Come utilizzare API inotify in lingua C

Inotify è un'API Linux utilizzata per il monitoraggio degli eventi del file system.

Questo articolo ti mostrerà come viene utilizzato inotify per monitorare la creazione, la cancellazione o la modifica di file e directory del file system Linux.

Per monitorare un file o una directory specifici tramite Inotify, seguire questi passaggi:

1. Crea un'istanza inotify usando il inotify_init ()
2. Aggiungi il percorso completo della directory o del file da monitorare e gli eventi da guardare utilizzando la funzione inatify_add_watch (). Nella stessa funzione, specifichiamo quali eventi (su Crea, su accesso, su modifica ecc.), le modifiche ai file o le modifiche alla directory devono essere monitorate.
3. Attendere che si verifichino eventi e leggi il buffer, che contiene uno o più eventi verificatisi, usando il Leggere() O Selezionare()
4. Processo l'evento che si è verificato, quindi torna al passaggio 3 per attendere altri eventi e ripetere.
5. Rimuovere il descrittore dell'orologio usando il inatify_rm_watch ()
6. Chiudi l'istanza inotificata.

Ora vedremo le funzioni utilizzate per l'API inotify.

File di intestazione: sys/inotify.H

inotify_init () funzione :

Sintassi: int inotify_init (void)

Argomenti: nessun argomento.

Valori di ritorno: al successo, la funzione restituisce un nuovo descrittore di file, per fallimento la funzione restituisce -1.

inatify_add_watch () funzione:

Sintassi: int inotify_add_watch (int fd, const char *pathname, Uint32_t Mask)

Argomenti:

Questa funzione prende tre argomenti.

Il 1^st Argomento (FD) è un descrittore di file che si riferisce all'istanza inotify (valore di ritorno di inotify_init () funzione) .

Il 2^nd L'argomento è il percorso della directory o del file che viene monitorato.

Il 3^Rd L'argomento è una maschera bit. La maschera bit rappresenta gli eventi che vengono osservati. Possiamo guardare uno o più eventi che usano bitwise o.

Valori di ritorno: Al successo, la funzione restituisce un descrittore di orologi, per fallimento la funzione restituisce -1.

inatify_rm_watch () funzione:

Sintassi: int inotify_rm_watch (int fd, int32_t wd)

Argomenti:

Questa funzione prende due argomenti.

Il 1^st Argomento (FD) è un descrittore di file che si riferisce all'istanza inotify (valore di ritorno di inotify_init () funzione) .

Il 2^nd Argomento (WD) è un descrittore di orologi (valore di ritorno di inatify_add_watch () funzione) .

Valori di ritorno: Al successo, la funzione restituisce 0, per errore la funzione restituisce -1.

Noi usiamo Leggere() funzione (dichiarata in unistd.H intestazione file) per leggere il buffer, che viene archiviato le informazioni degli eventi si sono verificati sotto forma di inotify_event struttura. IL inotify_event La struttura è dichiarata in sys/inotify.H File di intestazione:

struct inotify_event
int32t WD;
maschera uint32_t;
cookie uint32_t;
uint32_t len;
nome del personaggio[];

IL inotify_event La struttura rappresenta un evento di file system restituito dal sistema inotify e contiene i seguenti membri:

• Wd: Watch descrittore (valore di ritorno di inatify_add_watch () funzione)
• maschera: Una maschera un po 'che include tutti i tipi di eventi
• biscotto: Numero univoco che identifica gli eventi
• len: Numero di byte nel campo Nome
• nome: Nome del file o directory in cui si è verificato l'evento

Di seguito è riportato un esempio funzionante, utilizzando l'API inotify:

Inotificare.F del file:

#includere
#includere
#includere
#includere
#includere
#include // libreria per funzione fcntl
#define max_events 1024 /* Numero massimo di eventi da elaborare* /
#define len_name 16 /* Supponendo che la lunghezza del nome file
non supererà 16 byte*/
#define event_size (sizeof (struct inotify_event)) /*dimensione di un evento* /
#define buf_len (max_events * (event_size + len_name))
/*buffer per archiviare i dati degli eventi*/
int fd, wd;
void sig_handler (int sig)
/* Passaggio 5. Rimuovere il descrittore dell'orologio e chiudere l'istanza inotifica*/
inotify_rm_watch (fd, wd);
chiudere (FD);
uscita (0);

int main (int argc, char ** argv)
char *path_to_be_watched;
segnale (sigint, sig_handler);
path_to_be_watched = argv [1];
/* Passo 1. Inizializza inotify */
fd = inotify_init ();
if (fcntl (fd, f_setfl, o_nonblock) < 0) // error checking for fcntl
uscita (2);
/* Passo 2. Aggiungi orologio */
wd = inotify_add_watch (fd, path_to_be_watched, in_modify | in_create | in_delete);
if (wd ==-1)
printf ("Impossibile guardare: %s \ n", path_to_be_watched);

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

while (1)
int i = 0, lunghezza;
char buffer [buf_len];
/* Passaggio 3. Leggi Buffer*/
lunghezza = leggi (fd, buffer, buf_len);
/* Passaggio 4. Elaborare gli eventi che si sono verificati */
mentre iostruct inotify_event *event = (struct inotify_event *) & buffer [i];
if (event-> len)
if (event-> mask & in_create)
if (event-> mask & in_isdir)
printf ("La directory %s è stata creata.\ n ", event-> name);

altro
printf ("Il file %s è stato creato.\ n ", event-> name);


else if (event-> mask & in_delete)
if (event-> mask & in_isdir)
printf ("La directory %s è stata eliminata.\ n ", event-> name);

altro
printf ("Il file %s è stato eliminato.\ n ", event-> name);


else if (event-> mask & in_modify)
if (event-> mask & in_isdir)
printf ("La directory %s è stata modificata.\ n ", event-> name);

altro
printf ("Il file %s è stato modificato.\ n ", event-> name);



i + = event_size + event-> len;

Produzione:

Per eseguire il programma e vedere l'output, dobbiamo prima aprire due terminali. Un terminale viene utilizzato per eseguire il programma Inotificare.C. Nel secondo terminal, andiamo sul percorso che viene osservata da Inotify.C. Se creiamo una directory o un file, modifichiamo qualsiasi file o eliminiamo qualsiasi directory o file, li vedremo nel primo terminale.

Nel Inotificare.C Esempio, il unistd.H Il file di intestazione viene utilizzato per il file Leggere() E vicino() funzione, il stdlib.H Il file di intestazione viene utilizzato per il file Uscita() funzione, il segnale.H Il file di intestazione viene utilizzato per il file segnale() funzione e Sig_int macro (vedere la gestione del segnale per i dettagli) e il fcntl.H Il file di intestazione viene utilizzato per il file fcntl () funzione.

Dichiariamo fd (inotificare istanza) e Wd (Watch Descriptor) come variabili globali in modo che queste variabili siano accessibili da tutte le funzioni.

IL fcntl () la funzione viene utilizzata in modo che quando leggiamo usando il fd descrittore, il thread non verrà bloccato.

Successivamente, aggiungiamo un orologio usando il inatify_add_watch () funzione. Qui, passiamo FD, il percorso della directory che sarà guardato e la maschera. Puoi passare la maschera degli eventi che si desidera monitorare utilizzando bit-o o.

Ora, leggi il buffer. Le informazioni su uno o più eventi sono archiviate nel buffer. È possibile elaborare tutti gli eventi uno per uno usando il loop. Puoi controllare l'evento-> maschera per sapere quale tipo di eventi sono accaduti.

Usiamo un infinito durante il ciclo per verificare continuamente quando si sono verificati eventi. Se non si sono verificati eventi, la funzione read () ritorna con uno 0. Il valore di ritorno della funzione read () è memorizzato nella variabile di lunghezza. Quando il valore della variabile di lunghezza è maggiore di zero, si sono verificati uno o più eventi.

Noi usiamo il Sig_int segnale (premere ctrl+c) per uscire dal processo. Quando si preme Ctrl+C, il sig_handler () La funzione è chiamata (vedere la gestione del segnale per i dettagli). Questa funzione rimuove il descrittore di orologi, chiude l'istanza inotify fd, ed esce dal programma.

Conclusione

È possibile utilizzare API inotify nelle tue applicazioni per monitoraggio, debug, automazione e altro ancora. Qui, abbiamo visto il flusso di esecuzione dell'API inotify.