miscutils/inotifyd.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * simple inotify daemon
   4  * reports filesystem changes via userspace agent
   5  *
   6  * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
   7  *
   8  * Licensed under GPLv2, see file LICENSE in this tarball for details.
   9  */
  10
  11 /*
  12  * Use as follows:
  13  * # inotifyd /user/space/agent dir/or/file/being/watched[:mask] ...
  14  *
  15  * When a filesystem event matching the specified mask is occured on specified file (or directory)
  16  * a userspace agent is spawned and given the following parameters:
  17  * $1. actual event(s)
  18  * $2. file (or directory) name
  19  * $3. name of subfile (if any), in case of watching a directory
  20  *
  21  * E.g. inotifyd ./dev-watcher /dev:n
  22  *
  23  * ./dev-watcher can be, say:
  24  * #!/bin/sh
  25  * echo "We have new device in here! Hello, $3!"
  26  *
  27  * See below for mask names explanation.
  28  */
  29
  30 #include "libbb.h"
  31 #include <sys/inotify.h>
  32
  33 static const char mask_names[] ALIGN1 =
  34         "a"     // 0x00000001   File was accessed
  35         "c"     // 0x00000002   File was modified
  36         "e"     // 0x00000004   Metadata changed
  37         "w"     // 0x00000008   Writtable file was closed
  38         "0"     // 0x00000010   Unwrittable file closed
  39         "r"     // 0x00000020   File was opened
  40         "m"     // 0x00000040   File was moved from X
  41         "y"     // 0x00000080   File was moved to Y
  42         "n"     // 0x00000100   Subfile was created
  43         "d"     // 0x00000200   Subfile was deleted
  44         "D"     // 0x00000400   Self was deleted
  45         "M"     // 0x00000800   Self was moved
  46 ;
  47
  48 extern int inotify_init(void);
  49 extern int inotify_add_watch(int fd, const char *path, uint32_t mask);
  50
  51 int inotifyd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
  52 int inotifyd_main(int argc UNUSED_PARAM, char **argv)
  53 {
  54         int n;
  55         unsigned mask = IN_ALL_EVENTS; // assume we want all events
  56         struct pollfd pfd;
  57         char **watched = ++argv; // watched name list
  58         const char *args[] = { *argv, NULL, NULL, NULL, NULL };
  59
  60         // sanity check: agent and at least one watch must be given
  61         if (!argv[1])
  62                 bb_show_usage();
  63
  64         // open inotify
  65         pfd.fd = inotify_init();
  66         if (pfd.fd < 0)
  67                 bb_perror_msg_and_die("no kernel support");
  68
  69         // setup watched
  70         while (*++argv) {
  71                 char *path = *argv;
  72                 char *masks = strchr(path, ':');
  73                 // if mask is specified ->
  74                 if (masks) {
  75                         *masks = '\0'; // split path and mask
  76                         // convert mask names to mask bitset
  77                         mask = 0;
  78                         while (*++masks) {
  79                                 int i = strchr(mask_names, *masks) - mask_names;
  80                                 if (i >= 0) {
  81                                         mask |= (1 << i);
  82                                 }
  83                         }
  84                 }
  85                 // add watch
  86                 n = inotify_add_watch(pfd.fd, path, mask);
  87                 if (n < 0)
  88                         bb_perror_msg_and_die("add watch (%s) failed", path);
  89                 //bb_error_msg("added %d [%s]:%4X", n, path, mask);
  90         }
  91
  92         // setup signals
  93         bb_signals(BB_FATAL_SIGS, record_signo);
  94
  95         // do watch
  96         pfd.events = POLLIN;
  97         while (1) {
  98                 ssize_t len;
  99                 void *buf;
 100                 struct inotify_event *ie;
 101
 102  again:
 103                 if (bb_got_signal)
 104                         break;
 105                 n = poll(&pfd, 1, -1);
 106                 // Signal interrupted us?
 107                 if (n < 0 && errno == EINTR)
 108                         goto again;
 109                 // Under Linux, above if() is not necessary.
 110                 // Non-fatal signals, e.g. SIGCHLD, when set to SIG_DFL,
 111                 // are not interrupting poll().
 112                 // Thus we can just break if n <= 0 (see below),
 113                 // because EINTR will happen only on SIGTERM et al.
 114                 // But this might be not true under other Unixes,
 115                 // and is generally way too subtle to depend on.
 116                 if (n <= 0) // strange error?
 117                         break;
 118
 119                 // read out all pending events
 120                 xioctl(pfd.fd, FIONREAD, &len);
 121 #define eventbuf bb_common_bufsiz1
 122                 ie = buf = (len <= sizeof(eventbuf)) ? eventbuf : xmalloc(len);
 123                 len = full_read(pfd.fd, buf, len);
 124                 // process events. N.B. events may vary in length
 125                 while (len > 0) {
 126                         int i;
 127                         char events[sizeof(mask_names)];
 128                         char *s = events;
 129                         unsigned m = ie->mask;
 130
 131                         for (i = 0; i < sizeof(mask_names)-1; ++i, m >>= 1) {
 132                                 if (m & 1)
 133                                         *s++ = mask_names[i];
 134                         }
 135                         *s = '\0';
 136                         //bb_error_msg("exec %s %08X\t%s\t%s\t%s", agent,
 137                         // ie->mask, events, watched[ie->wd], ie->len ? ie->name : "");
 138                         args[1] = events;
 139                         args[2] = watched[ie->wd];
 140                         args[3] = ie->len ? ie->name : NULL;
 141                         wait4pid(xspawn((char **)args));
 142                         // next event
 143                         i = sizeof(struct inotify_event) + ie->len;
 144                         len -= i;
 145                         ie = (void*)((char*)ie + i);
 146                 }
 147                 if (eventbuf != buf)
 148                         free(buf);
 149         }
 150
 151         return EXIT_SUCCESS;
 152 }