Como usar a API inotificada em C Language

Inotify é uma API Linux usada para o monitoramento de eventos do sistema de arquivos.

Este artigo mostrará como o Inotify é usado para rastrear a criação, exclusão ou modificação de arquivos e diretórios do sistema de arquivos Linux.

Para monitorar um arquivo ou diretório específico usando inotificar, siga estas etapas:

1. Criar uma instância inotificada usando o Inotify_init ()
2. Adicione o caminho completo do diretório ou do arquivo para monitorar e os eventos para assistir usando a função Inotify_add_watch (). Na mesma função, especificamos quais eventos (na criação, no acesso, no modificar etc.), alterações nos arquivos ou alterações no diretório devem ser monitoradas.
3. Aguarde os eventos ocorrem e leia o buffer, que contém um ou mais eventos que ocorreram, usando o ler() ou SELECT ()
4. Processe o evento que ocorreu, depois retorne à Etapa 3 para aguardar mais eventos e repetir.
5. Remova o descritor do relógio usando o Inotify_rm_watch ()
6. Feche a instância Inotify.

Agora, veremos as funções usadas para inotificar a API.

Arquivo de cabeçalho: Sys/Inotify.h

Inotify_init () função:

Sintaxe: int inotify_init (void)

Argumentos: sem argumentos.

Valores de retorno: no sucesso, a função retorna um novo descritor de arquivo, para falha a função retorna -1.

Inotify_add_watch () função:

Sintaxe: int inotify_add_watch (int fd, const char *pathname, uint32_t máscara)

Argumentos:

Esta função leva três argumentos.

O 1^st Argumento (FD) é um descritor de arquivo que se refere à instância inotificada (valor de retorno de Inotify_init () função) .

O 2^nd O argumento é o caminho do diretório ou arquivo que está sendo monitorado.

O 3^rd O argumento é uma máscara de bits. A máscara de bits representa os eventos que estão sendo observados. Podemos assistir a um ou mais eventos usando bit-ou.

Valores de retorno: No sucesso, a função retorna um descritor de relógio, para falha a função retorna -1.

Inotify_rm_watch () função:

Sintaxe: int inotify_rm_watch (int fd, int32_t wd)

Argumentos:

Esta função leva dois argumentos.

O 1^st Argumento (FD) é um descritor de arquivo que se refere à instância inotificada (valor de retorno de Inotify_init () função) .

O 2^nd argumento (WD) é um descritor de relógio (valor de retorno de Inotify_add_watch () função) .

Valores de retorno: No sucesso, a função retorna 0, para falha, a função retorna -1.

Nós usamos ler() função (declarada em unistd.h cabeçalho arquivo) para ler o buffer, que é armazenado as informações dos eventos ocorreram na forma do Inotify_Event estrutura. O Inotify_Event estrutura é declarada em Sys/Inotify.h arquivo de cabeçalho:

struct inotify_event
int32t wd;
máscara uint32_t;
UINT32_T Cookie;
uint32_t len;
nome do personagem[];

O Inotify_Event A estrutura representa um evento de sistema de arquivos retornado pelo sistema Inotify e contém os seguintes membros:

• wd: Assistir descritor (valor de retorno de Inotify_add_watch () função)
• mascarar: Uma máscara de bits que inclui todos os tipos de eventos
• biscoito: Número único que identifica eventos
• Len: Número de bytes no campo Nome
• nome: Nome do arquivo ou diretório em que o evento ocorreu

Abaixo está um exemplo de funcionamento, usando a API Inotify:

Inotificar.Arquivo C:

#incluir
#incluir
#incluir
#incluir
#incluir
#include // biblioteca para função fcntl
#Define max_events 1024 /* Número máximo de eventos para processar* /
#define len_name 16 /* assumindo que o comprimento do nome do arquivo
não excederá 16 bytes*/
#define event_size (sizeof (struct inotify_event)) /*tamanho de um evento* /
#define buf_len (max_events * (event_size + len_name))
/*Buffer para armazenar os dados dos eventos*/
int fd, wd;
void sig_handler (int sig)
/* Etapa 5. Remova o descritor do relógio e feche a instância do Inotify*/
Inotify_rm_watch (FD, WD);
fechar (FD);
saída (0);

int main (int argc, char ** argv)
char *path_to_be_watched;
sinal (sigint, sig_handler);
path_to_be_watched = argv [1];
/* Passo 1. Inicialize Inotify */
fd = inotify_init ();
if (fcntl (fd, f_setfl, o_nonblock) < 0) // error checking for fcntl
saída (2);
/* Passo 2. Adicionar relógio */
wd = inotify_add_watch (fd, path_to_be_watched, in_modify | in_create | in_delete);
if (wd ==-1)
printf ("Não foi possível assistir: %s \ n", path_to_be_watched);

outro
printf ("Assistindo: %s \ n", path_to_be_watched);

enquanto (1)
int i = 0, comprimento;
buffer de char [buf_len];
/* Etapa 3. Leia o buffer*/
comprimento = leitura (fd, buffer, buf_len);
/* Passo 4. Processar os eventos que ocorreram */
enquanto eustruct inotify_event *event = (struct inotify_event *) e buffer [i];
if (event-> len)
if (event-> máscara & in_create)
if (event-> mask & in_isdir)
printf ("O diretório %s foi criado.\ n ", evento-> nome);

outro
printf ("O arquivo %s foi criado.\ n ", evento-> nome);


caso contrário, if (event-> máscara & in_delete)
if (event-> mask & in_isdir)
printf ("O diretório %s foi excluído.\ n ", evento-> nome);

outro
printf ("O arquivo %s foi excluído.\ n ", evento-> nome);


caso contrário, if (event-> mask & in_modify)
if (event-> mask & in_isdir)
printf ("O diretório %s foi modificado.\ n ", evento-> nome);

outro
printf ("O arquivo %s foi modificado.\ n ", evento-> nome);



i + = event_size + event-> len;

Saída:

Para executar o programa e ver a saída, devemos primeiro abrir dois terminais. Um terminal é usado para executar o programa Inotificar.c. No segundo terminal, vamos ao caminho que está sendo observado pelo Inotify.c. Se criarmos algum diretório ou arquivo, modificar qualquer arquivo ou excluir qualquer diretório ou arquivo, veremos -os no primeiro terminal.

No Inotificar.c exemplo, o unistd.h O arquivo de cabeçalho é usado para o ler() e fechar() função, o stdlib.h O arquivo de cabeçalho é usado para o saída() função, o sinal.h O arquivo de cabeçalho é usado para o sinal() função e o Sig_int macro (consulte o manuseio de sinal para obter detalhes) e o fcntl.h O arquivo de cabeçalho é usado para o fcntl () função.

Nós declaramos fd (Inotify Instância) e wd (Descritor de relógio) como variáveis ​​globais para que essas variáveis ​​sejam acessíveis a partir de todas as funções.

O fcntl () a função é usada para que quando lemos usando o fd Descritor, o tópico não será bloqueado.

Em seguida, adicionamos um relógio usando o Inotify_add_watch () função. Aqui, passamos pelo FD, o caminho do diretório que será observado e a máscara. Você pode passar a máscara dos eventos que deseja monitorar usando bit-ou.

Agora, leia o buffer. Informações sobre um ou mais eventos são armazenadas no buffer. Você pode processar todos os eventos um por um usando o loop. Você pode verificar o evento-> máscara para saber que tipo de eventos ocorreram.

Usamos um infinito enquanto o loop verifica continuamente quando os eventos ocorreram. Se nenhum evento aconteceu, a função read () retorna com 0. O valor de retorno da função read () é armazenado na variável de comprimento. Quando o valor da variável de comprimento é maior que zero, um ou mais eventos ocorreram.

Nós usamos o Sig_int sinal (pressione ctrl+c) para sair do processo. Quando você pressiona Ctrl+C, o sig_handler () A função é chamada (consulte o manuseio de sinal para obter detalhes). Esta função remove o descritor do relógio, fecha a instância Inotify fd, e sai do programa.

Conclusão

Você pode usar a API INOTIFY em seus próprios aplicativos para monitoramento, depuração, automação e muito mais, à sua maneira. Aqui, vimos o fluxo de execução da API INOTIFY.