#include <sys/select.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>

/**
 * Compilation : gcc inotify-exemple.c -o inotify-exemple -O2 -Wall -W -Werror -ansi -pedantic
 **/

int fd, wd;

void sigint_handler(int signum)
{
    (void) signum;

    /* Nous ne surveillons plus ce fichier/répertoire */
    if (inotify_rm_watch(fd, wd)) {
        perror("inotify_rm_watch");
        exit(EXIT_FAILURE);
    }

    /* Fermeture du descripteur de fichier obtenu lors de l'initialisation d'inotify */
    if (close(fd) < 0) {
        perror("close");
        exit(EXIT_FAILURE);
    }

    exit(EXIT_SUCCESS);
}

void afficher_masque(int mask)
{
    printf("Evénement : ");
    if (mask & IN_ACCESS)
        printf("Accès");
    if (mask & IN_MODIFY)
        printf("Modification");
    if (mask & IN_ATTRIB)
        printf("Attributs");
    if (mask & IN_CLOSE)
        printf("Fermeture");
    if (mask & IN_OPEN)
        printf("Ouverture");
    if (mask & IN_MOVED_FROM)
        printf("Déplacé de");
    if (mask & IN_MOVED_TO)
        printf("Déplacé vers");
    if (mask & IN_MOVE_SELF)
        printf("Lui-même déplacé");
    if (mask & IN_DELETE)
        printf("Suppression");
    if (mask & IN_CREATE)
        printf("Création");
    if (mask & IN_DELETE_SELF)
        printf("Lui-même supprimé");
    if (mask & IN_UNMOUNT)
        printf("N'est pas monté");
    if (mask & IN_Q_OVERFLOW)
        printf("Queue saturée");
    if (mask & IN_IGNORED)
        printf("Ignoré");
    if (mask & IN_ISDIR)
        printf("(répertoire)");
    else
        printf("(fichier)");
}

int main(int argc, char *argv[])
{
    size_t r;
    fd_set fds;
    char buffer[8192];
    struct inotify_event *event;

    if (argc != 2) {
        fprintf(stderr, "usage : %s fichier_ou_répertoire_à_monitorer\n", argv[0]);
        return EXIT_FAILURE;
    }

    /* Initialisation d'inotify */
    fd = inotify_init();
    if (fd < 0) {
        perror("inotify_init");
        return EXIT_FAILURE;
    }

    /* Surveillance du fichier/répertoire passé en paramètre
     * On accepte tous les évènements possibles */
    wd = inotify_add_watch(fd, argv[1], IN_ALL_EVENTS);
    if (wd < 0) {
        perror("inotify_add_watch");
        return EXIT_FAILURE;
    }

    printf("Monitoring : '%s' (numéro = %d)\n", argv[1], wd);

    /* Capture de SIGINT (Ctrl + C) */
    signal(SIGINT, sigint_handler);

    while (1) {
        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        if (select(fd + 1, &fds, NULL, NULL, 0) <= 0) {
            continue;
        }

        /* Obtention des informations sur l'évènement qui vient de se produire */
        r = read(fd, buffer, sizeof(buffer));
        if (r <= 0) {
            perror("read");
            return EXIT_FAILURE;
        }

        event = (struct inotify_event *) buffer;
        printf("Fichier surveillé n°%d\t", event->wd);
        afficher_masque(event->mask);

        if (event->len) {
            printf("\tObjet : %s", event->name);
        }
        printf("\n");
    }

    return EXIT_FAILURE;
}

#include <sys/types.h>
#include <sys/select.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <signal.h>
#include <syscall.h>
#include <stdlib.h>
#include <stdio.h>
#include <syslog.h>
#include <string.h>
#include <errno.h>

/**
 * Compilation (adapter les chemins relatifs à Apache à votre propre configuration) :
 *     gcc inotify-apache.c -o inotify-apache -O2 -Wall -W -Werror -pedantic -DHTTPD_CONF='"/etc/httpd.conf"' -DPID_FILE='"/var/run/httpd.pid"'
 **/

#define my_perror(msg) \
    syslog(LOG_ERR, msg ": %s", strerror(errno))

int fd, wd;

void sigterm_handler(int signum)
{
    (void) signum;

    exit(EXIT_SUCCESS);
}

void fin_programme() {
    if (wd > 0) {
        /* Nous ne surveillons plus ce fichier/répertoire */
        if (inotify_rm_watch(fd, wd)) { /* Génère parfois une erreur ici, bug ? */
            my_perror("inotify_rm_watch");
        }
    }
    if (fd > 0) {
        /* Fermeture du descripteur de fichier obtenu lors de l'initialisation d'inotify */
        if (close(fd) < 0) {
            my_perror("close");
        }
    }
    closelog();
}

int get_pid() {
    int pid;
    FILE *fp;

    fp = fopen(PID_FILE, "r");
    if (fp == NULL) {
        return -1;
    }
    fscanf(fp, "%d", &pid);
    fclose(fp);
    return pid;
}

int main()
{
    int pid;
    size_t r;
    fd_set fds;
    struct inotify_event event;
    extern char *__progname;

    if (daemon(0, 0)) {
        perror("daemon");
        return EXIT_FAILURE;
    }
    openlog(__progname, LOG_PID, LOG_DAEMON);

    fd = wd = -1;

    /* Initialisation d'inotify */
    fd = inotify_init();
    if (fd < 0) {
        my_perror("inotify_init");
        return EXIT_FAILURE;
    }

    if (atexit(fin_programme)) {
        syslog(LOG_ERR, "atexit");
        return EXIT_FAILURE;
    }

    /* Surveillance du fichier de configuration d'Apache
     * Seuls les évènements liés à l'écriture nous intéressent */
    wd = inotify_add_watch(fd, HTTPD_CONF, IN_MODIFY);
    if (wd < 0) {
        my_perror("inotify_add_watch");
        return EXIT_FAILURE;
    }

    /* Capture de SIGTERM */
    signal(SIGTERM, sigterm_handler);

    while (1) {
        FD_ZERO(&fds);
        FD_SET(fd, &fds);
        if (select(fd + 1, &fds, NULL, NULL, 0) <= 0) {
            continue;
        }

        /* Obtention des informations sur l'évènement qui vient de se produire */
        r = read(fd, &event, sizeof(event));
        if (r <= 0) {
            my_perror("read");
            return EXIT_FAILURE;
        }

        if ((event.mask & IN_MODIFY) || (event.mask & IN_IGNORED)) {
            if (event.mask & IN_IGNORED) {
                wd = inotify_add_watch(fd, HTTPD_CONF, IN_MODIFY);
                if (wd < 0) {
                    my_perror("inotify_add_watch");
                    return EXIT_FAILURE;
                }
            }
            /* Le "redémarrage" d'apache se fait ici (un signal HUP suffira) */
            pid = get_pid();
            if (pid == -1) {
                syslog(LOG_ERR, "Impossible de récupérer le PID du processus principal d'Apache !");
                return EXIT_FAILURE;
            }
            if (kill(pid, SIGHUP)) {
                my_perror("kill");
                return EXIT_FAILURE;
            }
        } else {
            syslog(LOG_ERR, "Evènement inattendu : %08X !", event.mask);
            exit(EXIT_FAILURE);
        }
    }

    return EXIT_FAILURE;
}

#!/usr/bin/perl

use strict;

use Linux::Inotify2;
use Proc::Daemon;
use Unix::Syslog qw(:subs :macros);

use constant PID_FILE => '/var/run/named/named.pid';
use constant NAMED_CONFDIR => '/etc/bind';

# On rend le programme indépendant et l'exécute en tâche de fond
Proc::Daemon::Init;
# Tout message sera logué via syslog
openlog $0 =~ s|.*/||, LOG_PID, LOG_DAEMON;

# Création d'une instance inotify
my $inotify = new Linux::Inotify2 or &error("Impossible de créer une nouvelle instance inotify : %m");
# Mise sous surveillance du répertoire
my $watch = $inotify->watch(NAMED_CONFDIR, IN_CREATE|IN_MODIFY|IN_MOVE|IN_DELETE)
    or &error("La création de l'observateur a échoué : %m");

# Sera appelé à la fin du programme
sub fin {
    $watch->cancel;
    closelog;
    exit 0;
}

# Logue les erreurs graves et met fin au programme
sub error {
    syslog LOG_ERR, @_[0];
    &fin;
}

# Récupèration du PID inscrit par bind/named
sub get_pid {
    open(IN, "< " . PID_FILE) or &error("Impossible d'ouvrir " . PID_FILE . " en lecture : %m");
    (my $pid = <IN>) =~ s/([0-9]+)/$1/;
    close IN;
    return $pid;
}

# Les signaux pour intercepter la fin du programme et la rendre effective proprement
$SIG{'TERM'} = \&fin;

# Boucle infinie ayant pour but de récupérer les évènements
while (1) {
    my @events = $inotify->read;
    unless (@events > 0) {
        syslog LOG_WARNING, "erreur sur read: %m";
        last;
    }
    foreach (@events) {
        my $pid = &get_pid;
        #syslog LOG_DEBUG, "Fichier : %s %s [%08X]\n", ($_->fullname, $_->name, $_->mask);
        kill(1, $pid) or &error("Impossible d'envoyer le signal SIGHUP à $pid : %m")
            if $_->fullname =~ /\.(conf|zone)$/;
    }
}