summaryrefslogtreecommitdiff
path: root/release/src/router/busybox/miscutils/inotifyd.c
diff options
context:
space:
mode:
Diffstat (limited to 'release/src/router/busybox/miscutils/inotifyd.c')
-rw-r--r--release/src/router/busybox/miscutils/inotifyd.c176
1 files changed, 176 insertions, 0 deletions
diff --git a/release/src/router/busybox/miscutils/inotifyd.c b/release/src/router/busybox/miscutils/inotifyd.c
new file mode 100644
index 00000000..d6b5d246
--- /dev/null
+++ b/release/src/router/busybox/miscutils/inotifyd.c
@@ -0,0 +1,176 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * simple inotify daemon
+ * reports filesystem changes via userspace agent
+ *
+ * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
+ */
+
+/*
+ * Use as follows:
+ * # inotifyd /user/space/agent dir/or/file/being/watched[:mask] ...
+ *
+ * When a filesystem event matching the specified mask is occured on specified file (or directory)
+ * a userspace agent is spawned and given the following parameters:
+ * $1. actual event(s)
+ * $2. file (or directory) name
+ * $3. name of subfile (if any), in case of watching a directory
+ *
+ * E.g. inotifyd ./dev-watcher /dev:n
+ *
+ * ./dev-watcher can be, say:
+ * #!/bin/sh
+ * echo "We have new device in here! Hello, $3!"
+ *
+ * See below for mask names explanation.
+ */
+
+#include "libbb.h"
+#include <sys/inotify.h>
+
+static const char mask_names[] ALIGN1 =
+ "a" // 0x00000001 File was accessed
+ "c" // 0x00000002 File was modified
+ "e" // 0x00000004 Metadata changed
+ "w" // 0x00000008 Writtable file was closed
+ "0" // 0x00000010 Unwrittable file closed
+ "r" // 0x00000020 File was opened
+ "m" // 0x00000040 File was moved from X
+ "y" // 0x00000080 File was moved to Y
+ "n" // 0x00000100 Subfile was created
+ "d" // 0x00000200 Subfile was deleted
+ "D" // 0x00000400 Self was deleted
+ "M" // 0x00000800 Self was moved
+ "\0" // 0x00001000 (unused)
+ // Kernel events, always reported:
+ "u" // 0x00002000 Backing fs was unmounted
+ "o" // 0x00004000 Event queued overflowed
+ "x" // 0x00008000 File is no longer watched (usually deleted)
+;
+enum {
+ MASK_BITS = sizeof(mask_names) - 1
+};
+
+int inotifyd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int inotifyd_main(int argc, char **argv)
+{
+ int n;
+ unsigned mask;
+ struct pollfd pfd;
+ char **watches; // names of files being watched
+ const char *args[5];
+
+ // sanity check: agent and at least one watch must be given
+ if (!argv[1] || !argv[2])
+ bb_show_usage();
+
+ argv++;
+ // inotify_add_watch will number watched files
+ // starting from 1, thus watches[0] is unimportant,
+ // and 1st file name is watches[1].
+ watches = argv;
+ args[0] = *argv;
+ args[4] = NULL;
+ argc -= 2; // number of files we watch
+
+ // open inotify
+ pfd.fd = inotify_init();
+ if (pfd.fd < 0)
+ bb_perror_msg_and_die("no kernel support");
+
+ // setup watches
+ while (*++argv) {
+ char *path = *argv;
+ char *masks = strchr(path, ':');
+
+ mask = 0x0fff; // assuming we want all non-kernel events
+ // if mask is specified ->
+ if (masks) {
+ *masks = '\0'; // split path and mask
+ // convert mask names to mask bitset
+ mask = 0;
+ while (*++masks) {
+ const char *found;
+ found = memchr(mask_names, *masks, MASK_BITS);
+ if (found)
+ mask |= (1 << (found - mask_names));
+ }
+ }
+ // add watch
+ n = inotify_add_watch(pfd.fd, path, mask);
+ if (n < 0)
+ bb_perror_msg_and_die("add watch (%s) failed", path);
+ //bb_error_msg("added %d [%s]:%4X", n, path, mask);
+ }
+
+ // setup signals
+ bb_signals(BB_FATAL_SIGS, record_signo);
+
+ // do watch
+ pfd.events = POLLIN;
+ while (1) {
+ int len;
+ void *buf;
+ struct inotify_event *ie;
+ again:
+ if (bb_got_signal)
+ break;
+ n = poll(&pfd, 1, -1);
+ // Signal interrupted us?
+ if (n < 0 && errno == EINTR)
+ goto again;
+ // Under Linux, above if() is not necessary.
+ // Non-fatal signals, e.g. SIGCHLD, when set to SIG_DFL,
+ // are not interrupting poll().
+ // Thus we can just break if n <= 0 (see below),
+ // because EINTR will happen only on SIGTERM et al.
+ // But this might be not true under other Unixes,
+ // and is generally way too subtle to depend on.
+ if (n <= 0) // strange error?
+ break;
+
+ // read out all pending events
+ // (NB: len must be int, not ssize_t or long!)
+ xioctl(pfd.fd, FIONREAD, &len);
+#define eventbuf bb_common_bufsiz1
+ ie = buf = (len <= sizeof(eventbuf)) ? eventbuf : xmalloc(len);
+ len = full_read(pfd.fd, buf, len);
+ // process events. N.B. events may vary in length
+ while (len > 0) {
+ int i;
+ // cache relevant events mask
+ unsigned m = ie->mask & ((1 << MASK_BITS) - 1);
+ if (m) {
+ char events[MASK_BITS + 1];
+ char *s = events;
+ for (i = 0; i < MASK_BITS; ++i, m >>= 1) {
+ if ((m & 1) && (mask_names[i] != '\0'))
+ *s++ = mask_names[i];
+ }
+ *s = '\0';
+// bb_error_msg("exec %s %08X\t%s\t%s\t%s", args[0],
+// ie->mask, events, watches[ie->wd], ie->len ? ie->name : "");
+ args[1] = events;
+ args[2] = watches[ie->wd];
+ args[3] = ie->len ? ie->name : NULL;
+ wait4pid(xspawn((char **)args));
+ // we are done if all files got final x event
+ if (ie->mask & 0x8000) {
+ if (--argc <= 0)
+ goto done;
+ inotify_rm_watch(pfd.fd, ie->wd);
+ }
+ }
+ // next event
+ i = sizeof(struct inotify_event) + ie->len;
+ len -= i;
+ ie = (void*)((char*)ie + i);
+ }
+ if (eventbuf != buf)
+ free(buf);
+ } // while (1)
+ done:
+ return bb_got_signal;
+}