busybox/miscutils/inotifyd.c

/* 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
;

extern int inotify_init(void);
extern int inotify_add_watch(int fd, const char *path, uint32_t mask);

int inotifyd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int inotifyd_main(int argc UNUSED_PARAM, char **argv)
{
	int n;
	unsigned mask = IN_ALL_EVENTS; // assume we want all events
	struct pollfd pfd;
	char **watched = ++argv; // watched name list
	const char *args[] = { *argv, NULL, NULL, NULL, NULL };

	// sanity check: agent and at least one watch must be given
	if (!argv[1])
		bb_show_usage();

	// open inotify
	pfd.fd = inotify_init();
	if (pfd.fd < 0)
		bb_perror_msg_and_die("no kernel support");

	// setup watched
	while (*++argv) {
		char *path = *argv;
		char *masks = strchr(path, ':');
		// if mask is specified ->
		if (masks) {
			*masks = '\0'; // split path and mask
			// convert mask names to mask bitset
			mask = 0;
			while (*++masks) {
				int i = strchr(mask_names, *masks) - mask_names;
				if (i >= 0) {
					mask |= (1 << i);
				}
			}
		}
		// 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) {
		ssize_t 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
		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;
			char events[sizeof(mask_names)];
			char *s = events;
			unsigned m = ie->mask;

			for (i = 0; i < sizeof(mask_names)-1; ++i, m >>= 1) {
				if (m & 1)
					*s++ = mask_names[i];
			}
			*s = '\0';
			//bb_error_msg("exec %s %08X\t%s\t%s\t%s", agent,
			// ie->mask, events, watched[ie->wd], ie->len ? ie->name : "");
			args[1] = events;
			args[2] = watched[ie->wd];
			args[3] = ie->len ? ie->name : NULL;
			wait4pid(xspawn((char **)args));
			// next event
			i = sizeof(struct inotify_event) + ie->len;
			len -= i;
			ie = (void*)((char*)ie + i);
		}
		if (eventbuf != buf)
			free(buf);
	}

	return EXIT_SUCCESS;
}
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	}