From 4aca87515a5083ae0e31ce3177189fd43b6d05ac Mon Sep 17 00:00:00 2001 From: Andreas Baumann Date: Sat, 3 Jan 2015 13:58:15 +0100 Subject: patch to Vanilla Tomato 1.28 --- release/src/router/busybox/miscutils/inotifyd.c | 176 ++++++++++++++++++++++++ 1 file changed, 176 insertions(+) create mode 100644 release/src/router/busybox/miscutils/inotifyd.c (limited to 'release/src/router/busybox/miscutils/inotifyd.c') 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 + * + * 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 + +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; +} -- cgit v1.2.3-54-g00ecf