xref: /freebsd/sbin/devd/devd.cc (revision a0ee8cc6)
1 /*-
2  * Copyright (c) 2002-2010 M. Warner Losh.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * my_system is a variation on lib/libc/stdlib/system.c:
27  *
28  * Copyright (c) 1988, 1993
29  *	The Regents of the University of California.  All rights reserved.
30  *
31  * Redistribution and use in source and binary forms, with or without
32  * modification, are permitted provided that the following conditions
33  * are met:
34  * 1. Redistributions of source code must retain the above copyright
35  *    notice, this list of conditions and the following disclaimer.
36  * 2. Redistributions in binary form must reproduce the above copyright
37  *    notice, this list of conditions and the following disclaimer in the
38  *    documentation and/or other materials provided with the distribution.
39  * 4. Neither the name of the University nor the names of its contributors
40  *    may be used to endorse or promote products derived from this software
41  *    without specific prior written permission.
42  *
43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  */
55 
56 /*
57  * DEVD control daemon.
58  */
59 
60 // TODO list:
61 //	o devd.conf and devd man pages need a lot of help:
62 //	  - devd needs to document the unix domain socket
63 //	  - devd.conf needs more details on the supported statements.
64 
65 #include <sys/cdefs.h>
66 __FBSDID("$FreeBSD$");
67 
68 #include <sys/param.h>
69 #include <sys/socket.h>
70 #include <sys/stat.h>
71 #include <sys/sysctl.h>
72 #include <sys/types.h>
73 #include <sys/wait.h>
74 #include <sys/un.h>
75 
76 #include <cctype>
77 #include <cerrno>
78 #include <cstdlib>
79 #include <cstdio>
80 #include <csignal>
81 #include <cstring>
82 #include <cstdarg>
83 
84 #include <dirent.h>
85 #include <err.h>
86 #include <fcntl.h>
87 #include <libutil.h>
88 #include <paths.h>
89 #include <poll.h>
90 #include <regex.h>
91 #include <syslog.h>
92 #include <unistd.h>
93 
94 #include <algorithm>
95 #include <map>
96 #include <string>
97 #include <list>
98 #include <vector>
99 
100 #include "devd.h"		/* C compatible definitions */
101 #include "devd.hh"		/* C++ class definitions */
102 
103 #define STREAMPIPE "/var/run/devd.pipe"
104 #define SEQPACKETPIPE "/var/run/devd.seqpacket.pipe"
105 #define CF "/etc/devd.conf"
106 #define SYSCTL "hw.bus.devctl_queue"
107 
108 /*
109  * Since the client socket is nonblocking, we must increase its send buffer to
110  * handle brief event storms.  On FreeBSD, AF_UNIX sockets don't have a receive
111  * buffer, so the client can't increase the buffersize by itself.
112  *
113  * For example, when creating a ZFS pool, devd emits one 165 character
114  * resource.fs.zfs.statechange message for each vdev in the pool.  The kernel
115  * allocates a 4608B mbuf for each message.  Modern technology places a limit of
116  * roughly 450 drives/rack, and it's unlikely that a zpool will ever be larger
117  * than that.
118  *
119  * 450 drives * 165 bytes / drive = 74250B of data in the sockbuf
120  * 450 drives * 4608B / drive = 2073600B of mbufs in the sockbuf
121  *
122  * We can't directly set the sockbuf's mbuf limit, but we can do it indirectly.
123  * The kernel sets it to the minimum of a hard-coded maximum value and sbcc *
124  * kern.ipc.sockbuf_waste_factor, where sbcc is the socket buffer size set by
125  * the user.  The default value of kern.ipc.sockbuf_waste_factor is 8.  If we
126  * set the bufsize to 256k and use the kern.ipc.sockbuf_waste_factor, then the
127  * kernel will set the mbuf limit to 2MB, which is just large enough for 450
128  * drives.  It also happens to be the same as the hardcoded maximum value.
129  */
130 #define CLIENT_BUFSIZE 262144
131 
132 using namespace std;
133 
134 typedef struct client {
135 	int fd;
136 	int socktype;
137 } client_t;
138 
139 extern FILE *yyin;
140 extern int lineno;
141 
142 static const char notify = '!';
143 static const char nomatch = '?';
144 static const char attach = '+';
145 static const char detach = '-';
146 
147 static struct pidfh *pfh;
148 
149 static int no_daemon = 0;
150 static int daemonize_quick = 0;
151 static int quiet_mode = 0;
152 static unsigned total_events = 0;
153 static volatile sig_atomic_t got_siginfo = 0;
154 static volatile sig_atomic_t romeo_must_die = 0;
155 
156 static const char *configfile = CF;
157 
158 static void devdlog(int priority, const char* message, ...)
159 	__printflike(2, 3);
160 static void event_loop(void);
161 static void usage(void);
162 
163 template <class T> void
164 delete_and_clear(vector<T *> &v)
165 {
166 	typename vector<T *>::const_iterator i;
167 
168 	for (i = v.begin(); i != v.end(); ++i)
169 		delete *i;
170 	v.clear();
171 }
172 
173 config cfg;
174 
175 event_proc::event_proc() : _prio(-1)
176 {
177 	_epsvec.reserve(4);
178 }
179 
180 event_proc::~event_proc()
181 {
182 	delete_and_clear(_epsvec);
183 }
184 
185 void
186 event_proc::add(eps *eps)
187 {
188 	_epsvec.push_back(eps);
189 }
190 
191 bool
192 event_proc::matches(config &c) const
193 {
194 	vector<eps *>::const_iterator i;
195 
196 	for (i = _epsvec.begin(); i != _epsvec.end(); ++i)
197 		if (!(*i)->do_match(c))
198 			return (false);
199 	return (true);
200 }
201 
202 bool
203 event_proc::run(config &c) const
204 {
205 	vector<eps *>::const_iterator i;
206 
207 	for (i = _epsvec.begin(); i != _epsvec.end(); ++i)
208 		if (!(*i)->do_action(c))
209 			return (false);
210 	return (true);
211 }
212 
213 action::action(const char *cmd)
214 	: _cmd(cmd)
215 {
216 	// nothing
217 }
218 
219 action::~action()
220 {
221 	// nothing
222 }
223 
224 static int
225 my_system(const char *command)
226 {
227 	pid_t pid, savedpid;
228 	int pstat;
229 	struct sigaction ign, intact, quitact;
230 	sigset_t newsigblock, oldsigblock;
231 
232 	if (!command)		/* just checking... */
233 		return (1);
234 
235 	/*
236 	 * Ignore SIGINT and SIGQUIT, block SIGCHLD. Remember to save
237 	 * existing signal dispositions.
238 	 */
239 	ign.sa_handler = SIG_IGN;
240 	::sigemptyset(&ign.sa_mask);
241 	ign.sa_flags = 0;
242 	::sigaction(SIGINT, &ign, &intact);
243 	::sigaction(SIGQUIT, &ign, &quitact);
244 	::sigemptyset(&newsigblock);
245 	::sigaddset(&newsigblock, SIGCHLD);
246 	::sigprocmask(SIG_BLOCK, &newsigblock, &oldsigblock);
247 	switch (pid = ::fork()) {
248 	case -1:			/* error */
249 		break;
250 	case 0:				/* child */
251 		/*
252 		 * Restore original signal dispositions and exec the command.
253 		 */
254 		::sigaction(SIGINT, &intact, NULL);
255 		::sigaction(SIGQUIT,  &quitact, NULL);
256 		::sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
257 		/*
258 		 * Close the PID file, and all other open descriptors.
259 		 * Inherit std{in,out,err} only.
260 		 */
261 		cfg.close_pidfile();
262 		::closefrom(3);
263 		::execl(_PATH_BSHELL, "sh", "-c", command, (char *)NULL);
264 		::_exit(127);
265 	default:			/* parent */
266 		savedpid = pid;
267 		do {
268 			pid = ::wait4(savedpid, &pstat, 0, (struct rusage *)0);
269 		} while (pid == -1 && errno == EINTR);
270 		break;
271 	}
272 	::sigaction(SIGINT, &intact, NULL);
273 	::sigaction(SIGQUIT,  &quitact, NULL);
274 	::sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
275 	return (pid == -1 ? -1 : pstat);
276 }
277 
278 bool
279 action::do_action(config &c)
280 {
281 	string s = c.expand_string(_cmd.c_str());
282 	devdlog(LOG_INFO, "Executing '%s'\n", s.c_str());
283 	my_system(s.c_str());
284 	return (true);
285 }
286 
287 match::match(config &c, const char *var, const char *re) :
288 	_inv(re[0] == '!'),
289 	_var(var),
290 	_re(c.expand_string(_inv ? re + 1 : re, "^", "$"))
291 {
292 	regcomp(&_regex, _re.c_str(), REG_EXTENDED | REG_NOSUB | REG_ICASE);
293 }
294 
295 match::~match()
296 {
297 	regfree(&_regex);
298 }
299 
300 bool
301 match::do_match(config &c)
302 {
303 	const string &value = c.get_variable(_var);
304 	bool retval;
305 
306 	/*
307 	 * This function gets called WAY too often to justify calling syslog()
308 	 * each time, even at LOG_DEBUG.  Because if syslogd isn't running, it
309 	 * can consume excessive amounts of systime inside of connect().  Only
310 	 * log when we're in -d mode.
311 	 */
312 	if (no_daemon) {
313 		devdlog(LOG_DEBUG, "Testing %s=%s against %s, invert=%d\n",
314 		    _var.c_str(), value.c_str(), _re.c_str(), _inv);
315 	}
316 
317 	retval = (regexec(&_regex, value.c_str(), 0, NULL, 0) == 0);
318 	if (_inv == 1)
319 		retval = (retval == 0) ? 1 : 0;
320 
321 	return (retval);
322 }
323 
324 #include <sys/sockio.h>
325 #include <net/if.h>
326 #include <net/if_media.h>
327 
328 media::media(config &, const char *var, const char *type)
329 	: _var(var), _type(-1)
330 {
331 	static struct ifmedia_description media_types[] = {
332 		{ IFM_ETHER,		"Ethernet" },
333 		{ IFM_TOKEN,		"Tokenring" },
334 		{ IFM_FDDI,		"FDDI" },
335 		{ IFM_IEEE80211,	"802.11" },
336 		{ IFM_ATM,		"ATM" },
337 		{ -1,			"unknown" },
338 		{ 0, NULL },
339 	};
340 	for (int i = 0; media_types[i].ifmt_string != NULL; ++i)
341 		if (strcasecmp(type, media_types[i].ifmt_string) == 0) {
342 			_type = media_types[i].ifmt_word;
343 			break;
344 		}
345 }
346 
347 media::~media()
348 {
349 }
350 
351 bool
352 media::do_match(config &c)
353 {
354 	string value;
355 	struct ifmediareq ifmr;
356 	bool retval;
357 	int s;
358 
359 	// Since we can be called from both a device attach/detach
360 	// context where device-name is defined and what we want,
361 	// as well as from a link status context, where subsystem is
362 	// the name of interest, first try device-name and fall back
363 	// to subsystem if none exists.
364 	value = c.get_variable("device-name");
365 	if (value.empty())
366 		value = c.get_variable("subsystem");
367 	devdlog(LOG_DEBUG, "Testing media type of %s against 0x%x\n",
368 		    value.c_str(), _type);
369 
370 	retval = false;
371 
372 	s = socket(PF_INET, SOCK_DGRAM, 0);
373 	if (s >= 0) {
374 		memset(&ifmr, 0, sizeof(ifmr));
375 		strncpy(ifmr.ifm_name, value.c_str(), sizeof(ifmr.ifm_name));
376 
377 		if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0 &&
378 		    ifmr.ifm_status & IFM_AVALID) {
379 			devdlog(LOG_DEBUG, "%s has media type 0x%x\n",
380 				    value.c_str(), IFM_TYPE(ifmr.ifm_active));
381 			retval = (IFM_TYPE(ifmr.ifm_active) == _type);
382 		} else if (_type == -1) {
383 			devdlog(LOG_DEBUG, "%s has unknown media type\n",
384 				    value.c_str());
385 			retval = true;
386 		}
387 		close(s);
388 	}
389 
390 	return (retval);
391 }
392 
393 const string var_list::bogus = "_$_$_$_$_B_O_G_U_S_$_$_$_$_";
394 const string var_list::nothing = "";
395 
396 const string &
397 var_list::get_variable(const string &var) const
398 {
399 	map<string, string>::const_iterator i;
400 
401 	i = _vars.find(var);
402 	if (i == _vars.end())
403 		return (var_list::bogus);
404 	return (i->second);
405 }
406 
407 bool
408 var_list::is_set(const string &var) const
409 {
410 	return (_vars.find(var) != _vars.end());
411 }
412 
413 void
414 var_list::set_variable(const string &var, const string &val)
415 {
416 	/*
417 	 * This function gets called WAY too often to justify calling syslog()
418 	 * each time, even at LOG_DEBUG.  Because if syslogd isn't running, it
419 	 * can consume excessive amounts of systime inside of connect().  Only
420 	 * log when we're in -d mode.
421 	 */
422 	if (no_daemon)
423 		devdlog(LOG_DEBUG, "setting %s=%s\n", var.c_str(), val.c_str());
424 	_vars[var] = val;
425 }
426 
427 void
428 config::reset(void)
429 {
430 	_dir_list.clear();
431 	delete_and_clear(_var_list_table);
432 	delete_and_clear(_attach_list);
433 	delete_and_clear(_detach_list);
434 	delete_and_clear(_nomatch_list);
435 	delete_and_clear(_notify_list);
436 }
437 
438 void
439 config::parse_one_file(const char *fn)
440 {
441 	devdlog(LOG_DEBUG, "Parsing %s\n", fn);
442 	yyin = fopen(fn, "r");
443 	if (yyin == NULL)
444 		err(1, "Cannot open config file %s", fn);
445 	lineno = 1;
446 	if (yyparse() != 0)
447 		errx(1, "Cannot parse %s at line %d", fn, lineno);
448 	fclose(yyin);
449 }
450 
451 void
452 config::parse_files_in_dir(const char *dirname)
453 {
454 	DIR *dirp;
455 	struct dirent *dp;
456 	char path[PATH_MAX];
457 
458 	devdlog(LOG_DEBUG, "Parsing files in %s\n", dirname);
459 	dirp = opendir(dirname);
460 	if (dirp == NULL)
461 		return;
462 	readdir(dirp);		/* Skip . */
463 	readdir(dirp);		/* Skip .. */
464 	while ((dp = readdir(dirp)) != NULL) {
465 		if (strcmp(dp->d_name + dp->d_namlen - 5, ".conf") == 0) {
466 			snprintf(path, sizeof(path), "%s/%s",
467 			    dirname, dp->d_name);
468 			parse_one_file(path);
469 		}
470 	}
471 	closedir(dirp);
472 }
473 
474 class epv_greater {
475 public:
476 	int operator()(event_proc *const&l1, event_proc *const&l2) const
477 	{
478 		return (l1->get_priority() > l2->get_priority());
479 	}
480 };
481 
482 void
483 config::sort_vector(vector<event_proc *> &v)
484 {
485 	stable_sort(v.begin(), v.end(), epv_greater());
486 }
487 
488 void
489 config::parse(void)
490 {
491 	vector<string>::const_iterator i;
492 
493 	parse_one_file(configfile);
494 	for (i = _dir_list.begin(); i != _dir_list.end(); ++i)
495 		parse_files_in_dir((*i).c_str());
496 	sort_vector(_attach_list);
497 	sort_vector(_detach_list);
498 	sort_vector(_nomatch_list);
499 	sort_vector(_notify_list);
500 }
501 
502 void
503 config::open_pidfile()
504 {
505 	pid_t otherpid;
506 
507 	if (_pidfile.empty())
508 		return;
509 	pfh = pidfile_open(_pidfile.c_str(), 0600, &otherpid);
510 	if (pfh == NULL) {
511 		if (errno == EEXIST)
512 			errx(1, "devd already running, pid: %d", (int)otherpid);
513 		warn("cannot open pid file");
514 	}
515 }
516 
517 void
518 config::write_pidfile()
519 {
520 
521 	pidfile_write(pfh);
522 }
523 
524 void
525 config::close_pidfile()
526 {
527 
528 	pidfile_close(pfh);
529 }
530 
531 void
532 config::remove_pidfile()
533 {
534 
535 	pidfile_remove(pfh);
536 }
537 
538 void
539 config::add_attach(int prio, event_proc *p)
540 {
541 	p->set_priority(prio);
542 	_attach_list.push_back(p);
543 }
544 
545 void
546 config::add_detach(int prio, event_proc *p)
547 {
548 	p->set_priority(prio);
549 	_detach_list.push_back(p);
550 }
551 
552 void
553 config::add_directory(const char *dir)
554 {
555 	_dir_list.push_back(string(dir));
556 }
557 
558 void
559 config::add_nomatch(int prio, event_proc *p)
560 {
561 	p->set_priority(prio);
562 	_nomatch_list.push_back(p);
563 }
564 
565 void
566 config::add_notify(int prio, event_proc *p)
567 {
568 	p->set_priority(prio);
569 	_notify_list.push_back(p);
570 }
571 
572 void
573 config::set_pidfile(const char *fn)
574 {
575 	_pidfile = fn;
576 }
577 
578 void
579 config::push_var_table()
580 {
581 	var_list *vl;
582 
583 	vl = new var_list();
584 	_var_list_table.push_back(vl);
585 	devdlog(LOG_DEBUG, "Pushing table\n");
586 }
587 
588 void
589 config::pop_var_table()
590 {
591 	delete _var_list_table.back();
592 	_var_list_table.pop_back();
593 	devdlog(LOG_DEBUG, "Popping table\n");
594 }
595 
596 void
597 config::set_variable(const char *var, const char *val)
598 {
599 	_var_list_table.back()->set_variable(var, val);
600 }
601 
602 const string &
603 config::get_variable(const string &var)
604 {
605 	vector<var_list *>::reverse_iterator i;
606 
607 	for (i = _var_list_table.rbegin(); i != _var_list_table.rend(); ++i) {
608 		if ((*i)->is_set(var))
609 			return ((*i)->get_variable(var));
610 	}
611 	return (var_list::nothing);
612 }
613 
614 bool
615 config::is_id_char(char ch) const
616 {
617 	return (ch != '\0' && (isalpha(ch) || isdigit(ch) || ch == '_' ||
618 	    ch == '-'));
619 }
620 
621 void
622 config::expand_one(const char *&src, string &dst)
623 {
624 	int count;
625 	string buffer;
626 
627 	src++;
628 	// $$ -> $
629 	if (*src == '$') {
630 		dst += *src++;
631 		return;
632 	}
633 
634 	// $(foo) -> $(foo)
635 	// Not sure if I want to support this or not, so for now we just pass
636 	// it through.
637 	if (*src == '(') {
638 		dst += '$';
639 		count = 1;
640 		/* If the string ends before ) is matched , return. */
641 		while (count > 0 && *src) {
642 			if (*src == ')')
643 				count--;
644 			else if (*src == '(')
645 				count++;
646 			dst += *src++;
647 		}
648 		return;
649 	}
650 
651 	// $[^A-Za-z] -> $\1
652 	if (!isalpha(*src)) {
653 		dst += '$';
654 		dst += *src++;
655 		return;
656 	}
657 
658 	// $var -> replace with value
659 	do {
660 		buffer += *src++;
661 	} while (is_id_char(*src));
662 	dst.append(get_variable(buffer));
663 }
664 
665 const string
666 config::expand_string(const char *src, const char *prepend, const char *append)
667 {
668 	const char *var_at;
669 	string dst;
670 
671 	/*
672 	 * 128 bytes is enough for 2427 of 2438 expansions that happen
673 	 * while parsing config files, as tested on 2013-01-30.
674 	 */
675 	dst.reserve(128);
676 
677 	if (prepend != NULL)
678 		dst = prepend;
679 
680 	for (;;) {
681 		var_at = strchr(src, '$');
682 		if (var_at == NULL) {
683 			dst.append(src);
684 			break;
685 		}
686 		dst.append(src, var_at - src);
687 		src = var_at;
688 		expand_one(src, dst);
689 	}
690 
691 	if (append != NULL)
692 		dst.append(append);
693 
694 	return (dst);
695 }
696 
697 bool
698 config::chop_var(char *&buffer, char *&lhs, char *&rhs) const
699 {
700 	char *walker;
701 
702 	if (*buffer == '\0')
703 		return (false);
704 	walker = lhs = buffer;
705 	while (is_id_char(*walker))
706 		walker++;
707 	if (*walker != '=')
708 		return (false);
709 	walker++;		// skip =
710 	if (*walker == '"') {
711 		walker++;	// skip "
712 		rhs = walker;
713 		while (*walker && *walker != '"')
714 			walker++;
715 		if (*walker != '"')
716 			return (false);
717 		rhs[-2] = '\0';
718 		*walker++ = '\0';
719 	} else {
720 		rhs = walker;
721 		while (*walker && !isspace(*walker))
722 			walker++;
723 		if (*walker != '\0')
724 			*walker++ = '\0';
725 		rhs[-1] = '\0';
726 	}
727 	while (isspace(*walker))
728 		walker++;
729 	buffer = walker;
730 	return (true);
731 }
732 
733 
734 char *
735 config::set_vars(char *buffer)
736 {
737 	char *lhs;
738 	char *rhs;
739 
740 	while (1) {
741 		if (!chop_var(buffer, lhs, rhs))
742 			break;
743 		set_variable(lhs, rhs);
744 	}
745 	return (buffer);
746 }
747 
748 void
749 config::find_and_execute(char type)
750 {
751 	vector<event_proc *> *l;
752 	vector<event_proc *>::const_iterator i;
753 	const char *s;
754 
755 	switch (type) {
756 	default:
757 		return;
758 	case notify:
759 		l = &_notify_list;
760 		s = "notify";
761 		break;
762 	case nomatch:
763 		l = &_nomatch_list;
764 		s = "nomatch";
765 		break;
766 	case attach:
767 		l = &_attach_list;
768 		s = "attach";
769 		break;
770 	case detach:
771 		l = &_detach_list;
772 		s = "detach";
773 		break;
774 	}
775 	devdlog(LOG_DEBUG, "Processing %s event\n", s);
776 	for (i = l->begin(); i != l->end(); ++i) {
777 		if ((*i)->matches(*this)) {
778 			(*i)->run(*this);
779 			break;
780 		}
781 	}
782 
783 }
784 
785 
786 static void
787 process_event(char *buffer)
788 {
789 	char type;
790 	char *sp;
791 
792 	sp = buffer + 1;
793 	devdlog(LOG_INFO, "Processing event '%s'\n", buffer);
794 	type = *buffer++;
795 	cfg.push_var_table();
796 	// No match doesn't have a device, and the format is a little
797 	// different, so handle it separately.
798 	switch (type) {
799 	case notify:
800 		sp = cfg.set_vars(sp);
801 		break;
802 	case nomatch:
803 		//? at location pnp-info on bus
804 		sp = strchr(sp, ' ');
805 		if (sp == NULL)
806 			return;	/* Can't happen? */
807 		*sp++ = '\0';
808 		while (isspace(*sp))
809 			sp++;
810 		if (strncmp(sp, "at ", 3) == 0)
811 			sp += 3;
812 		sp = cfg.set_vars(sp);
813 		while (isspace(*sp))
814 			sp++;
815 		if (strncmp(sp, "on ", 3) == 0)
816 			cfg.set_variable("bus", sp + 3);
817 		break;
818 	case attach:	/*FALLTHROUGH*/
819 	case detach:
820 		sp = strchr(sp, ' ');
821 		if (sp == NULL)
822 			return;	/* Can't happen? */
823 		*sp++ = '\0';
824 		cfg.set_variable("device-name", buffer);
825 		while (isspace(*sp))
826 			sp++;
827 		if (strncmp(sp, "at ", 3) == 0)
828 			sp += 3;
829 		sp = cfg.set_vars(sp);
830 		while (isspace(*sp))
831 			sp++;
832 		if (strncmp(sp, "on ", 3) == 0)
833 			cfg.set_variable("bus", sp + 3);
834 		break;
835 	}
836 
837 	cfg.find_and_execute(type);
838 	cfg.pop_var_table();
839 }
840 
841 int
842 create_socket(const char *name, int socktype)
843 {
844 	int fd, slen;
845 	struct sockaddr_un sun;
846 
847 	if ((fd = socket(PF_LOCAL, socktype, 0)) < 0)
848 		err(1, "socket");
849 	bzero(&sun, sizeof(sun));
850 	sun.sun_family = AF_UNIX;
851 	strlcpy(sun.sun_path, name, sizeof(sun.sun_path));
852 	slen = SUN_LEN(&sun);
853 	unlink(name);
854 	if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
855 	    	err(1, "fcntl");
856 	if (::bind(fd, (struct sockaddr *) & sun, slen) < 0)
857 		err(1, "bind");
858 	listen(fd, 4);
859 	chown(name, 0, 0);	/* XXX - root.wheel */
860 	chmod(name, 0666);
861 	return (fd);
862 }
863 
864 unsigned int max_clients = 10;	/* Default, can be overridden on cmdline. */
865 unsigned int num_clients;
866 
867 list<client_t> clients;
868 
869 void
870 notify_clients(const char *data, int len)
871 {
872 	list<client_t>::iterator i;
873 
874 	/*
875 	 * Deliver the data to all clients.  Throw clients overboard at the
876 	 * first sign of trouble.  This reaps clients who've died or closed
877 	 * their sockets, and also clients who are alive but failing to keep up
878 	 * (or who are maliciously not reading, to consume buffer space in
879 	 * kernel memory or tie up the limited number of available connections).
880 	 */
881 	for (i = clients.begin(); i != clients.end(); ) {
882 		int flags;
883 		if (i->socktype == SOCK_SEQPACKET)
884 			flags = MSG_EOR;
885 		else
886 			flags = 0;
887 
888 		if (send(i->fd, data, len, flags) != len) {
889 			--num_clients;
890 			close(i->fd);
891 			i = clients.erase(i);
892 			devdlog(LOG_WARNING, "notify_clients: send() failed; "
893 			    "dropping unresponsive client\n");
894 		} else
895 			++i;
896 	}
897 }
898 
899 void
900 check_clients(void)
901 {
902 	int s;
903 	struct pollfd pfd;
904 	list<client_t>::iterator i;
905 
906 	/*
907 	 * Check all existing clients to see if any of them have disappeared.
908 	 * Normally we reap clients when we get an error trying to send them an
909 	 * event.  This check eliminates the problem of an ever-growing list of
910 	 * zombie clients because we're never writing to them on a system
911 	 * without frequent device-change activity.
912 	 */
913 	pfd.events = 0;
914 	for (i = clients.begin(); i != clients.end(); ) {
915 		pfd.fd = i->fd;
916 		s = poll(&pfd, 1, 0);
917 		if ((s < 0 && s != EINTR ) ||
918 		    (s > 0 && (pfd.revents & POLLHUP))) {
919 			--num_clients;
920 			close(i->fd);
921 			i = clients.erase(i);
922 			devdlog(LOG_NOTICE, "check_clients:  "
923 			    "dropping disconnected client\n");
924 		} else
925 			++i;
926 	}
927 }
928 
929 void
930 new_client(int fd, int socktype)
931 {
932 	client_t s;
933 	int sndbuf_size;
934 
935 	/*
936 	 * First go reap any zombie clients, then accept the connection, and
937 	 * shut down the read side to stop clients from consuming kernel memory
938 	 * by sending large buffers full of data we'll never read.
939 	 */
940 	check_clients();
941 	s.socktype = socktype;
942 	s.fd = accept(fd, NULL, NULL);
943 	if (s.fd != -1) {
944 		sndbuf_size = CLIENT_BUFSIZE;
945 		if (setsockopt(s.fd, SOL_SOCKET, SO_SNDBUF, &sndbuf_size,
946 		    sizeof(sndbuf_size)))
947 			err(1, "setsockopt");
948 		shutdown(s.fd, SHUT_RD);
949 		clients.push_back(s);
950 		++num_clients;
951 	} else
952 		err(1, "accept");
953 }
954 
955 static void
956 event_loop(void)
957 {
958 	int rv;
959 	int fd;
960 	char buffer[DEVCTL_MAXBUF];
961 	int once = 0;
962 	int stream_fd, seqpacket_fd, max_fd;
963 	int accepting;
964 	timeval tv;
965 	fd_set fds;
966 
967 	fd = open(PATH_DEVCTL, O_RDONLY | O_CLOEXEC);
968 	if (fd == -1)
969 		err(1, "Can't open devctl device %s", PATH_DEVCTL);
970 	stream_fd = create_socket(STREAMPIPE, SOCK_STREAM);
971 	seqpacket_fd = create_socket(SEQPACKETPIPE, SOCK_SEQPACKET);
972 	accepting = 1;
973 	max_fd = max(fd, max(stream_fd, seqpacket_fd)) + 1;
974 	while (!romeo_must_die) {
975 		if (!once && !no_daemon && !daemonize_quick) {
976 			// Check to see if we have any events pending.
977 			tv.tv_sec = 0;
978 			tv.tv_usec = 0;
979 			FD_ZERO(&fds);
980 			FD_SET(fd, &fds);
981 			rv = select(fd + 1, &fds, &fds, &fds, &tv);
982 			// No events -> we've processed all pending events
983 			if (rv == 0) {
984 				devdlog(LOG_DEBUG, "Calling daemon\n");
985 				cfg.remove_pidfile();
986 				cfg.open_pidfile();
987 				daemon(0, 0);
988 				cfg.write_pidfile();
989 				once++;
990 			}
991 		}
992 		/*
993 		 * When we've already got the max number of clients, stop
994 		 * accepting new connections (don't put the listening sockets in
995 		 * the set), shrink the accept() queue to reject connections
996 		 * quickly, and poll the existing clients more often, so that we
997 		 * notice more quickly when any of them disappear to free up
998 		 * client slots.
999 		 */
1000 		FD_ZERO(&fds);
1001 		FD_SET(fd, &fds);
1002 		if (num_clients < max_clients) {
1003 			if (!accepting) {
1004 				listen(stream_fd, max_clients);
1005 				listen(seqpacket_fd, max_clients);
1006 				accepting = 1;
1007 			}
1008 			FD_SET(stream_fd, &fds);
1009 			FD_SET(seqpacket_fd, &fds);
1010 			tv.tv_sec = 60;
1011 			tv.tv_usec = 0;
1012 		} else {
1013 			if (accepting) {
1014 				listen(stream_fd, 0);
1015 				listen(seqpacket_fd, 0);
1016 				accepting = 0;
1017 			}
1018 			tv.tv_sec = 2;
1019 			tv.tv_usec = 0;
1020 		}
1021 		rv = select(max_fd, &fds, NULL, NULL, &tv);
1022 		if (got_siginfo) {
1023 			devdlog(LOG_NOTICE, "Events received so far=%u\n",
1024 			    total_events);
1025 			got_siginfo = 0;
1026 		}
1027 		if (rv == -1) {
1028 			if (errno == EINTR)
1029 				continue;
1030 			err(1, "select");
1031 		} else if (rv == 0)
1032 			check_clients();
1033 		if (FD_ISSET(fd, &fds)) {
1034 			rv = read(fd, buffer, sizeof(buffer) - 1);
1035 			if (rv > 0) {
1036 				total_events++;
1037 				if (rv == sizeof(buffer) - 1) {
1038 					devdlog(LOG_WARNING, "Warning: "
1039 					    "available event data exceeded "
1040 					    "buffer space\n");
1041 				}
1042 				notify_clients(buffer, rv);
1043 				buffer[rv] = '\0';
1044 				while (buffer[--rv] == '\n')
1045 					buffer[rv] = '\0';
1046 				process_event(buffer);
1047 			} else if (rv < 0) {
1048 				if (errno != EINTR)
1049 					break;
1050 			} else {
1051 				/* EOF */
1052 				break;
1053 			}
1054 		}
1055 		if (FD_ISSET(stream_fd, &fds))
1056 			new_client(stream_fd, SOCK_STREAM);
1057 		/*
1058 		 * Aside from the socket type, both sockets use the same
1059 		 * protocol, so we can process clients the same way.
1060 		 */
1061 		if (FD_ISSET(seqpacket_fd, &fds))
1062 			new_client(seqpacket_fd, SOCK_SEQPACKET);
1063 	}
1064 	close(fd);
1065 }
1066 
1067 /*
1068  * functions that the parser uses.
1069  */
1070 void
1071 add_attach(int prio, event_proc *p)
1072 {
1073 	cfg.add_attach(prio, p);
1074 }
1075 
1076 void
1077 add_detach(int prio, event_proc *p)
1078 {
1079 	cfg.add_detach(prio, p);
1080 }
1081 
1082 void
1083 add_directory(const char *dir)
1084 {
1085 	cfg.add_directory(dir);
1086 	free(const_cast<char *>(dir));
1087 }
1088 
1089 void
1090 add_nomatch(int prio, event_proc *p)
1091 {
1092 	cfg.add_nomatch(prio, p);
1093 }
1094 
1095 void
1096 add_notify(int prio, event_proc *p)
1097 {
1098 	cfg.add_notify(prio, p);
1099 }
1100 
1101 event_proc *
1102 add_to_event_proc(event_proc *ep, eps *eps)
1103 {
1104 	if (ep == NULL)
1105 		ep = new event_proc();
1106 	ep->add(eps);
1107 	return (ep);
1108 }
1109 
1110 eps *
1111 new_action(const char *cmd)
1112 {
1113 	eps *e = new action(cmd);
1114 	free(const_cast<char *>(cmd));
1115 	return (e);
1116 }
1117 
1118 eps *
1119 new_match(const char *var, const char *re)
1120 {
1121 	eps *e = new match(cfg, var, re);
1122 	free(const_cast<char *>(var));
1123 	free(const_cast<char *>(re));
1124 	return (e);
1125 }
1126 
1127 eps *
1128 new_media(const char *var, const char *re)
1129 {
1130 	eps *e = new media(cfg, var, re);
1131 	free(const_cast<char *>(var));
1132 	free(const_cast<char *>(re));
1133 	return (e);
1134 }
1135 
1136 void
1137 set_pidfile(const char *name)
1138 {
1139 	cfg.set_pidfile(name);
1140 	free(const_cast<char *>(name));
1141 }
1142 
1143 void
1144 set_variable(const char *var, const char *val)
1145 {
1146 	cfg.set_variable(var, val);
1147 	free(const_cast<char *>(var));
1148 	free(const_cast<char *>(val));
1149 }
1150 
1151 
1152 
1153 static void
1154 gensighand(int)
1155 {
1156 	romeo_must_die = 1;
1157 }
1158 
1159 /*
1160  * SIGINFO handler.  Will print useful statistics to the syslog or stderr
1161  * as appropriate
1162  */
1163 static void
1164 siginfohand(int)
1165 {
1166 	got_siginfo = 1;
1167 }
1168 
1169 /*
1170  * Local logging function.  Prints to syslog if we're daemonized; stderr
1171  * otherwise.
1172  */
1173 static void
1174 devdlog(int priority, const char* fmt, ...)
1175 {
1176 	va_list argp;
1177 
1178 	va_start(argp, fmt);
1179 	if (no_daemon)
1180 		vfprintf(stderr, fmt, argp);
1181 	else if ((! quiet_mode) || (priority <= LOG_WARNING))
1182 		vsyslog(priority, fmt, argp);
1183 	va_end(argp);
1184 }
1185 
1186 static void
1187 usage()
1188 {
1189 	fprintf(stderr, "usage: %s [-dnq] [-l connlimit] [-f file]\n",
1190 	    getprogname());
1191 	exit(1);
1192 }
1193 
1194 static void
1195 check_devd_enabled()
1196 {
1197 	int val = 0;
1198 	size_t len;
1199 
1200 	len = sizeof(val);
1201 	if (sysctlbyname(SYSCTL, &val, &len, NULL, 0) != 0)
1202 		errx(1, "devctl sysctl missing from kernel!");
1203 	if (val == 0) {
1204 		warnx("Setting " SYSCTL " to 1000");
1205 		val = 1000;
1206 		sysctlbyname(SYSCTL, NULL, NULL, &val, sizeof(val));
1207 	}
1208 }
1209 
1210 /*
1211  * main
1212  */
1213 int
1214 main(int argc, char **argv)
1215 {
1216 	int ch;
1217 
1218 	check_devd_enabled();
1219 	while ((ch = getopt(argc, argv, "df:l:nq")) != -1) {
1220 		switch (ch) {
1221 		case 'd':
1222 			no_daemon = 1;
1223 			break;
1224 		case 'f':
1225 			configfile = optarg;
1226 			break;
1227 		case 'l':
1228 			max_clients = MAX(1, strtoul(optarg, NULL, 0));
1229 			break;
1230 		case 'n':
1231 			daemonize_quick = 1;
1232 			break;
1233 		case 'q':
1234 			quiet_mode = 1;
1235 			break;
1236 		default:
1237 			usage();
1238 		}
1239 	}
1240 
1241 	cfg.parse();
1242 	if (!no_daemon && daemonize_quick) {
1243 		cfg.open_pidfile();
1244 		daemon(0, 0);
1245 		cfg.write_pidfile();
1246 	}
1247 	signal(SIGPIPE, SIG_IGN);
1248 	signal(SIGHUP, gensighand);
1249 	signal(SIGINT, gensighand);
1250 	signal(SIGTERM, gensighand);
1251 	signal(SIGINFO, siginfohand);
1252 	event_loop();
1253 	return (0);
1254 }
1255