Cómo utilizar la API inotify en lenguaje C

Inotify es una API de Linux utilizada para el monitoreo de eventos del sistema de archivos.

Este artículo le mostrará cómo se usa Inotify para rastrear la creación, eliminación o modificación de archivos y directorios del sistema de archivos de Linux.

Para monitorear un archivo o directorio específico usando Inotify, siga estos pasos:

Cree una instancia inotify usando el inotify_init ()
Agregue la ruta completa del directorio o el archivo para monitorear y los eventos para ver usando la función inotify_add_watch (). En la misma función, especificamos qué eventos (EN CREAR, EN ACCESO, EN MODIFICAR, etc.), los cambios en los archivos o los cambios en el directorio deben ser monitoreados.
Espere a que ocurran los eventos y lea el búfer, que contiene uno o más eventos que ocurrieron, usando el leer() o Seleccione()
Procese el evento que ha ocurrido, luego regrese al paso 3 para esperar más eventos y repita.
Quite el descriptor del reloj usando el inotify_rm_watch ()
Cerrar la instancia de inotify.

Ahora, veremos las funciones que se utilizan para Inotify API.

Archivo de cabecera: sys / inotify.h

inotify_init () función:

Sintaxis: int inotify_init (void)

Argumentos: Sin argumentos.

Valores devueltos: en caso de éxito, la función devuelve un nuevo descriptor de archivo, en caso de error, la función devuelve -1.

inotify_add_watch () función:

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

Argumentos:

Esta función toma tres argumentos.

El 1^{S t} argumento (fd) es un descriptor de archivo que se refiere a la instancia inotify (valor de retorno de inotify_init () función) .

El 2^{Dakota del Norte} el argumento es la ruta del directorio o archivo que se está monitoreando.

Los 3^rd el argumento es una máscara de bits. La máscara de bits representa los eventos que se están viendo. Podemos ver uno o más eventos usando bit a bit-OR.

Valores devueltos: En caso de éxito, la función devuelve un descriptor de vigilancia, en caso de error, la función devuelve -1.

inotify_rm_watch () función:

Sintaxis: int inotify_rm_watch (int fd, int32_t wd)

Argumentos:

Esta función toma dos argumentos.

El 1^{S t} argumento (fd) es un descriptor de archivo que se refiere a la instancia inotify (valor de retorno de inotify_init () función) .

El 2^{Dakota del Norte} argumento (wd) es un descriptor de vigilancia (valor de retorno de inotify_add_watch () función) .

Valores devueltos: En caso de éxito, la función devuelve 0, en caso de error, la función devuelve -1.

Usamos leer() función (declarada en unistd.h encabezamiento archivo) para leer el búfer, en el que se almacena la información de los eventos ocurridos en forma de inotify_event estructura. La inotify_event la estructura está declarada en sys / inotify.h archivo de cabecera:

struct inotify_event
int32t wd;
uint32_t mask;
cookie uint32_t;
uint32_t len;
nombre del personaje[];

La inotify_event La estructura representa un evento del sistema de archivos devuelto por el sistema inotify y contiene los siguientes miembros:

wd: Descriptor de reloj (valor de retorno de inotify_add_watch () función)
máscara: Una máscara de bits que incluye todos los tipos de eventos
Galleta: Número único que identifica eventos
len: Número de bytes en el campo de nombre
nombre: Nombre del archivo o directorio en el que ocurrió el evento

A continuación se muestra un ejemplo de trabajo, utilizando la API de Inotify:

Inotificar.archivo c:

#incluir
#incluir
#incluir
#incluir
#incluir
#incluir // biblioteca para la función fcntl

#define MAX_EVENTS 1024 / * Número máximo de eventos a procesar * /
#define LEN_NAME 16 / * Suponiendo que la longitud del nombre del archivo
no excederá los 16 bytes * /
#define EVENT_SIZE (sizeof (struct inotify_event)) / * tamaño de un evento * /
#define BUF_LEN (MAX_EVENTS * (EVENT_SIZE + LEN_NAME))
/ * búfer para almacenar los datos de eventos * /

int fd, wd;

void sig_handler (int sig)

/ * Paso 5. Elimina el descriptor del reloj y cierra la instancia de inotify * /
inotify_rm_watch (fd, wd);
cerrar (fd);
salir (0);

int main (int argc, char ** argv)

char * path_to_be_watched;
señal (SIGINT, sig_handler);

path_to_be_watched = argv [1];

/* Paso 1. Inicializar inotify * /
fd = inotify_init ();

si (fcntl (fd, F_SETFL, O_NONBLOCK) < 0) // error checking for fcntl
salida (2);

/* Paso 2. Agregar reloj * /
wd = inotify_add_watch (fd, path_to_be_watched, IN_MODIFY | IN_CREATE | IN_DELETE);

si (wd == - 1)
printf ("No se pudo ver:% s \ n", path_to_be_watched);

demás
printf ("Viendo:% s \ n", ruta_a_be_watched);

while (1)

int i = 0, longitud;
búfer de caracteres [BUF_LEN];

/* Paso 3. Leer búfer * /
longitud = lectura (fd, búfer, BUF_LEN);

/* Paso 4. Procesar los eventos ocurridos * /
mientras yo
struct inotify_event * event = (struct inotify_event *) & buffer [i];

si (evento-> len)
if (evento-> máscara & IN_CREATE)
if (evento-> máscara & IN_ISDIR)
printf ("El directorio% s fue creado.\ n ", evento-> nombre);

demás
printf ("El archivo% s fue creado.\ n ", evento-> nombre);

else if (evento-> máscara & IN_DELETE)
if (evento-> máscara & IN_ISDIR)
printf ("El directorio% s fue eliminado.\ n ", evento-> nombre);

demás
printf ("El archivo% s fue eliminado.\ n ", evento-> nombre);

else if (evento-> máscara & IN_MODIFY)
if (evento-> máscara & IN_ISDIR)
printf ("El directorio% s fue modificado.\ n ", evento-> nombre);

demás
printf ("El archivo% s fue modificado.\ n ", evento-> nombre);

i + = EVENT_SIZE + evento-> len;

Producción:

Para ejecutar el programa y ver la salida, primero debemos abrir dos terminales. Se utiliza una terminal para ejecutar el programa Inotificar.C. En la segunda terminal, nos dirigimos a la ruta que está siendo vigilada por Inotify.C. Si creamos algún directorio o archivo, modificamos algún archivo o borramos algún directorio o archivo, los veremos en la primera terminal.

En el Inotificar.C ejemplo, el unistd.h El archivo de encabezado se utiliza para leer() y cerca() función, la stdlib.h El archivo de encabezado se utiliza para Salida() función, la señal.h El archivo de encabezado se utiliza para señal() función y la SIG_INT macro (Ver manejo de señales para más detalles), y el fcntl.h El archivo de encabezado se utiliza para fcntl () función.

Declaramos fd (inotificar instancia) y wd (descriptor de reloj) como variables globales para que estas variables sean accesibles desde todas las funciones.

La fcntl () La función se usa para que cuando leemos usando la fd descriptor, el hilo no se bloqueará.

A continuación, agregamos un reloj usando el inotify_add_watch () función. Aquí, pasamos fd, la ruta del directorio que se observará y la máscara. Puede pasar la máscara de los eventos que desea monitorear usando bit a bit-OR.

Ahora, lee el búfer. La información sobre uno o más eventos se almacena en el búfer. Puede procesar todos los eventos uno por uno utilizando el bucle. Puede comprobar el evento-> máscara para saber qué tipo de eventos han sucedido.

Usamos un ciclo while infinito para verificar continuamente cuándo ocurrieron los eventos. Si no ha ocurrido ningún evento, la función read () regresa con un 0. El valor de retorno de la función read () se almacena en la variable de longitud. Cuando el valor de la variable de longitud es mayor que cero, se han producido uno o más eventos.

Usamos el SIG_INT señal (presione Ctrl + C) para salir del proceso. Cuando presiona Ctrl + C, el sig_handler () se llama a la función (ver manejo de señales para más detalles). Esta función elimina el descriptor del reloj, cierra la instancia inotify fd, y sale del programa.

Conclusión

Puede usar la API de Inotify en sus propias aplicaciones para monitorear, depurar, automatizar y más, a su manera. Aquí, hemos visto el flujo de ejecución de la API de Inotify.