Come utilizzare l'API inotify in linguaggio C

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

Questo articolo ti mostrerà come Inotify viene utilizzato per tracciare la creazione, l'eliminazione o la modifica di file e directory del file system Linux.

Per monitorare un file o una directory specifici utilizzando Inotify, segui questi passaggi:

Crea un'istanza inotify usando il pulsante inotify_init()
Aggiungi il percorso completo della directory o del file da monitorare e gli eventi da guardare utilizzando la funzione inotify_add_watch(). Nella stessa funzione specifichiamo quali eventi (ON CREATE, ON ACCESS, ON MODIFY etc.), le modifiche ai file o le modifiche alla directory devono essere monitorate.
Attendi che si verifichino eventi e leggi il buffer, che contiene uno o più eventi accaduti, utilizzando il tasto leggere() o Selezionare()
Elaborare l'evento che si è verificato, quindi tornare al passaggio 3 per attendere altri eventi e ripetere.
Rimuovere il descrittore dell'orologio utilizzando il inotify_rm_watch()
Chiudi l'istanza inotify.

Ora vedremo le funzioni utilizzate per Inotify API.

File di intestazione: sys/notify.h

inotify_init() funzione :

Sintassi: int inotify_init (void)

Argomenti: nessun argomento.

Valori di ritorno: in caso di successo, la funzione restituisce un nuovo descrittore di file, in caso di errore la funzione restituisce -1.

inotify_add_watch() funzione:

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

Argomenti:

Questa funzione accetta tre argomenti.

Il 1^sto argomento (fd) è un descrittore di file che fa riferimento all'istanza inotify (valore restituito di inotify_init() funzione) .

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

Il 3^rd l'argomento è una maschera di bit. La maschera di bit rappresenta gli eventi che vengono osservati. Possiamo guardare uno o più eventi usando bitwise-OR.

Valori di ritorno: In caso di successo, la funzione restituisce un descrittore di controllo, in caso di errore la funzione restituisce -1.

inotify_rm_watch() funzione:

Sintassi: int inotify_rm_watch ( int fd, int32_t wd )

Argomenti:

Questa funzione accetta due argomenti.

Il 1^sto argomento (fd) è un descrittore di file che fa riferimento all'istanza inotify (valore restituito di inotify_init() funzione) .

Il 2^nd argomento (wd) è un descrittore di controllo (valore restituito di inotify_add_watch() funzione) .

Valori di ritorno: In caso di successo, la funzione restituisce 0, in caso di errore la funzione restituisce -1.

Noi usiamo leggere() funzione (dichiarata in unistd.h intestazione file) per leggere il buffer, in cui sono memorizzate le informazioni degli eventi accaduti sotto forma di inotify_event struttura. Il inotify_event la struttura è dichiarata in sys/notify.h file di intestazione:

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

Il inotify_event la struttura rappresenta un evento del file system restituito dal sistema inotify e contiene i seguenti membri:

wd: Descrittore orologio (valore restituito dire inotify_add_watch() funzione)
maschera: Una maschera di bit che include tutti i tipi di evento
biscotto: Numero univoco che identifica gli eventi
len: Numero di byte nel campo del nome
nome: Nome del file o della directory in cui si è verificato l'evento

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

Inotifica.cfile:

#includere
#includere
#includere
#includere
#includere
#includere // libreria per la funzione fcntl

#define MAX_EVENTS 1024 /* Numero massimo di eventi da elaborare*/
#define LEN_NAME 16 /* Supponendo che la lunghezza del nome del file
non supererà i 16 byte*/
#define EVENT_SIZE ( sizeof (struct inotify_event) ) /*dimensione di un evento*/
#define BUF_LEN ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME ))
/*buffer per memorizzare i dati degli eventi*/

int fd,wd;

void sig_handler(int sig)

/* Passaggio 5. Rimuovi il descrittore di controllo e chiudi l'istanza inotify*/
inotify_rm_watch( fd, wd );
chiudi( fd );
uscita( 0 );

int main(int argc, char **argv)

char *percorso_da_essere_osservato;
signal(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("Guardando: %s\n",path_to_be_watched);

mentre(1)

int i=0,lunghezza;
char buffer[BUF_LEN];

/* Passaggio 3. Lettura buffer*/
lunghezza = read(fd,buffer,BUF_LEN);

/* Passaggio 4. Elabora gli eventi che si sono verificati */
mentre io
struct inotify_event *event = (struct inotify_event *) &buffer[i];

if(evento->len)
if ( evento->maschera & IN_CREATE )
if ( evento->maschera & IN_ISDIR )
printf("La directory %s è stata creata.\n", evento->nome);

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

else if ( evento->maschera & IN_DELETE )
if ( evento->maschera & IN_ISDIR )
printf("La directory %s è stata cancellata.\n", evento->nome);

altro
printf("Il file %s è stato cancellato.\n", evento->nome);

else if ( evento->maschera & IN_MODIFY )
if ( evento->maschera & IN_ISDIR )
printf("La directory %s è stata modificata.\n", evento->nome);

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

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 Inotifica.c. Nel secondo terminale, andiamo al percorso che viene osservato da Inotify.c. Se creiamo qualsiasi directory o file, modifichiamo qualsiasi file o eliminiamo qualsiasi directory o file, li vedremo sul primo terminale.

Nel Inotifica.c esempio, il unistd.h il file di intestazione viene utilizzato per il leggere() e vicino() funzione, il stdlib.h il file di intestazione viene utilizzato per il Uscita() funzione, il segnale.h il file di intestazione viene utilizzato per il segnale() funzione e il SIG_INT macro (vedere la gestione del segnale per i dettagli) e il fcntl.h il file di intestazione viene utilizzato per il fcntl() funzione.

Dichiariamo fd (notifica istanza) e wd (guarda il descrittore) 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 inotify_add_watch() funzione. Qui passiamo fd, il percorso della directory che verrà guardata e la maschera. Puoi passare la maschera degli eventi che vuoi monitorare usando bitwise-OR.

Ora leggi il buffer. Le informazioni su uno o più eventi sono memorizzate nel buffer. Puoi elaborare tutti gli eventi uno per uno usando il ciclo. Puoi controllare l'evento->maschera per sapere che tipo di eventi sono accaduti.

Usiamo un ciclo while infinito per controllare continuamente quando si sono verificati gli eventi. Se non si sono verificati eventi, la funzione read() restituisce uno 0. Il valore restituito dalla funzione read() è memorizzato nella variabile length length. Quando il valore della variabile 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 premi Ctrl+C, il sig_handler() viene chiamata la funzione (vedi gestione del segnale per i dettagli). Questa funzione rimuove il descrittore watch, chiude l'istanza inotify fd, ed esce dal programma.

Conclusione

Puoi utilizzare Inotify API nelle tue applicazioni per il monitoraggio, il debug, l'automazione e altro, a modo tuo. Qui, abbiamo visto il flusso di esecuzione dell'API Inotify.