xref: /dragonfly/sbin/devd/devd.cc (revision fcf53d9b) 
1 /*-
2  * Copyright (c) 2002-2003 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  * $FreeBSD: src/sbin/devd/devd.cc,v 1.33 2006/09/17 22:49:26 ru Exp $
27  * $DragonFly: src/sbin/devd/devd.cc,v 1.1 2008/10/03 00:26:21 hasso Exp $
28  */
29 
30 /*
31  * DEVD control daemon.
32  */
33 
34 // TODO list:
35 //	o devd.conf and devd man pages need a lot of help:
36 //	  - devd needs to document the unix domain socket
37 //	  - devd.conf needs more details on the supported statements.
38 
39 #include <sys/param.h>
40 #include <sys/socket.h>
41 #include <sys/stat.h>
42 #include <sys/sysctl.h>
43 #include <sys/types.h>
44 #include <sys/un.h>
45 
46 #include <ctype.h>
47 #include <dirent.h>
48 #include <errno.h>
49 #include <err.h>
50 #include <fcntl.h>
51 #include <libutil.h>
52 #include <regex.h>
53 #include <signal.h>
54 #include <stdlib.h>
55 #include <stdio.h>
56 #include <string.h>
57 #include <unistd.h>
58 
59 #include <algorithm>
60 #include <map>
61 #include <string>
62 #include <list>
63 #include <vector>
64 
65 #include "devd.h"		/* C compatible definitions */
66 #include "devd.hh"		/* C++ class definitions */
67 
68 #define PIPE "/var/run/devd.pipe"
69 #define CF "/etc/devd.conf"
70 #define SYSCTL "hw.bus.devctl_disable"
71 
72 using namespace std;
73 
74 extern FILE *yyin;
75 extern int lineno;
76 
77 static const char notify = '!';
78 static const char nomatch = '?';
79 static const char attach = '+';
80 static const char detach = '-';
81 
82 int Dflag;
83 int dflag;
84 int nflag;
85 int romeo_must_die = 0;
86 
87 static const char *configfile = CF;
88 
89 static void event_loop(void);
90 static void usage(void);
91 
92 template <class T> void
93 delete_and_clear(vector<T *> &v)
94 {
95 	typename vector<T *>::const_iterator i;
96 
97 	for (i = v.begin(); i != v.end(); i++)
98 		delete *i;
99 	v.clear();
100 }
101 
102 config cfg;
103 
104 event_proc::event_proc() : _prio(-1)
105 {
106 	// nothing
107 }
108 
109 event_proc::~event_proc()
110 {
111 	delete_and_clear(_epsvec);
112 }
113 
114 void
115 event_proc::add(eps *eps)
116 {
117 	_epsvec.push_back(eps);
118 }
119 
120 bool
121 event_proc::matches(config &c)
122 {
123 	vector<eps *>::const_iterator i;
124 
125 	for (i = _epsvec.begin(); i != _epsvec.end(); i++)
126 		if (!(*i)->do_match(c))
127 			return (false);
128 	return (true);
129 }
130 
131 bool
132 event_proc::run(config &c)
133 {
134 	vector<eps *>::const_iterator i;
135 
136 	for (i = _epsvec.begin(); i != _epsvec.end(); i++)
137 		if (!(*i)->do_action(c))
138 			return (false);
139 	return (true);
140 }
141 
142 action::action(const char *cmd)
143 	: _cmd(cmd)
144 {
145 	// nothing
146 }
147 
148 action::~action()
149 {
150 	// nothing
151 }
152 
153 bool
154 action::do_action(config &c)
155 {
156 	string s = c.expand_string(_cmd);
157 	if (Dflag)
158 		fprintf(stderr, "Executing '%s'\n", s.c_str());
159 	::system(s.c_str());
160 	return (true);
161 }
162 
163 match::match(config &c, const char *var, const char *re)
164 	: _var(var)
165 {
166 	string pattern = re;
167 	_re = "^";
168 	_re.append(c.expand_string(string(re)));
169 	_re.append("$");
170 	regcomp(&_regex, _re.c_str(), REG_EXTENDED | REG_NOSUB | REG_ICASE);
171 }
172 
173 match::~match()
174 {
175 	regfree(&_regex);
176 }
177 
178 bool
179 match::do_match(config &c)
180 {
181 	string value = c.get_variable(_var);
182 	bool retval;
183 
184 	if (Dflag)
185 		fprintf(stderr, "Testing %s=%s against %s\n", _var.c_str(),
186 		    value.c_str(), _re.c_str());
187 
188 	retval = (regexec(&_regex, value.c_str(), 0, NULL, 0) == 0);
189 	return retval;
190 }
191 
192 #include <sys/sockio.h>
193 #include <net/if.h>
194 #include <net/if_media.h>
195 
196 media::media(config &, const char *var, const char *type)
197 	: _var(var), _type(-1)
198 {
199 	static struct ifmedia_description media_types[] = {
200 		{ IFM_ETHER,		"Ethernet" },
201 		{ IFM_IEEE80211,	"802.11" },
202 		{ IFM_ATM,		"ATM" },
203 		{ IFM_CARP,		"CARP" },
204 		{ -1,			"unknown" },
205 		{ 0, NULL },
206 	};
207 	for (int i = 0; media_types[i].ifmt_string != NULL; i++)
208 		if (strcasecmp(type, media_types[i].ifmt_string) == 0) {
209 			_type = media_types[i].ifmt_word;
210 			break;
211 		}
212 }
213 
214 media::~media()
215 {
216 }
217 
218 bool
219 media::do_match(config &c)
220 {
221 	string value;
222 	struct ifmediareq ifmr;
223 	bool retval;
224 	int s;
225 
226 	// Since we can be called from both a device attach/detach
227 	// context where device-name is defined and what we want,
228 	// as well as from a link status context, where subsystem is
229 	// the name of interest, first try device-name and fall back
230 	// to subsystem if none exists.
231 	value = c.get_variable("device-name");
232 	if (value.length() == 0)
233 		value = c.get_variable("subsystem");
234 	if (Dflag)
235 		fprintf(stderr, "Testing media type of %s against 0x%x\n",
236 		    value.c_str(), _type);
237 
238 	retval = false;
239 
240 	s = socket(PF_INET, SOCK_DGRAM, 0);
241 	if (s >= 0) {
242 		memset(&ifmr, 0, sizeof(ifmr));
243 		strncpy(ifmr.ifm_name, value.c_str(), sizeof(ifmr.ifm_name));
244 
245 		if (ioctl(s, SIOCGIFMEDIA, (caddr_t)&ifmr) >= 0 &&
246 		    ifmr.ifm_status & IFM_AVALID) {
247 			if (Dflag)
248 				fprintf(stderr, "%s has media type 0x%x\n",
249 				    value.c_str(), IFM_TYPE(ifmr.ifm_active));
250 			retval = (IFM_TYPE(ifmr.ifm_active) == _type);
251 		} else if (_type == -1) {
252 			if (Dflag)
253 				fprintf(stderr, "%s has unknown media type\n",
254 				    value.c_str());
255 			retval = true;
256 		}
257 		close(s);
258 	}
259 
260 	return retval;
261 }
262 
263 const string var_list::bogus = "_$_$_$_$_B_O_G_U_S_$_$_$_$_";
264 const string var_list::nothing = "";
265 
266 const string &
267 var_list::get_variable(const string &var) const
268 {
269 	map<string, string>::const_iterator i;
270 
271 	i = _vars.find(var);
272 	if (i == _vars.end())
273 		return (var_list::bogus);
274 	return (i->second);
275 }
276 
277 bool
278 var_list::is_set(const string &var) const
279 {
280 	return (_vars.find(var) != _vars.end());
281 }
282 
283 void
284 var_list::set_variable(const string &var, const string &val)
285 {
286 	if (Dflag)
287 		fprintf(stderr, "setting %s=%s\n", var.c_str(), val.c_str());
288 	_vars[var] = val;
289 }
290 
291 void
292 config::reset(void)
293 {
294 	_dir_list.clear();
295 	delete_and_clear(_var_list_table);
296 	delete_and_clear(_attach_list);
297 	delete_and_clear(_detach_list);
298 	delete_and_clear(_nomatch_list);
299 	delete_and_clear(_notify_list);
300 }
301 
302 void
303 config::parse_one_file(const char *fn)
304 {
305 	if (Dflag)
306 		printf("Parsing %s\n", fn);
307 	yyin = fopen(fn, "r");
308 	if (yyin == NULL)
309 		err(1, "Cannot open config file %s", fn);
310 	lineno = 1;
311 	if (yyparse() != 0)
312 		errx(1, "Cannot parse %s at line %d", fn, lineno);
313 	fclose(yyin);
314 }
315 
316 void
317 config::parse_files_in_dir(const char *dirname)
318 {
319 	DIR *dirp;
320 	struct dirent *dp;
321 	char path[PATH_MAX];
322 
323 	if (Dflag)
324 		printf("Parsing files in %s\n", dirname);
325 	dirp = opendir(dirname);
326 	if (dirp == NULL)
327 		return;
328 	readdir(dirp);		/* Skip . */
329 	readdir(dirp);		/* Skip .. */
330 	while ((dp = readdir(dirp)) != NULL) {
331 		if (strcmp(dp->d_name + dp->d_namlen - 5, ".conf") == 0) {
332 			snprintf(path, sizeof(path), "%s/%s",
333 			    dirname, dp->d_name);
334 			parse_one_file(path);
335 		}
336 	}
337 }
338 
339 class epv_greater {
340 public:
341 	int operator()(event_proc *const&l1, event_proc *const&l2)
342 	{
343 		return (l1->get_priority() > l2->get_priority());
344 	}
345 };
346 
347 void
348 config::sort_vector(vector<event_proc *> &v)
349 {
350 	sort(v.begin(), v.end(), epv_greater());
351 }
352 
353 void
354 config::parse(void)
355 {
356 	vector<string>::const_iterator i;
357 
358 	parse_one_file(configfile);
359 	for (i = _dir_list.begin(); i != _dir_list.end(); i++)
360 		parse_files_in_dir((*i).c_str());
361 	sort_vector(_attach_list);
362 	sort_vector(_detach_list);
363 	sort_vector(_nomatch_list);
364 	sort_vector(_notify_list);
365 }
366 
367 void
368 config::open_pidfile()
369 {
370 	if (pidfile(NULL))
371 		errx(1, "devd already running");
372 }
373 
374 void
375 config::add_attach(int prio, event_proc *p)
376 {
377 	p->set_priority(prio);
378 	_attach_list.push_back(p);
379 }
380 
381 void
382 config::add_detach(int prio, event_proc *p)
383 {
384 	p->set_priority(prio);
385 	_detach_list.push_back(p);
386 }
387 
388 void
389 config::add_directory(const char *dir)
390 {
391 	_dir_list.push_back(string(dir));
392 }
393 
394 void
395 config::add_nomatch(int prio, event_proc *p)
396 {
397 	p->set_priority(prio);
398 	_nomatch_list.push_back(p);
399 }
400 
401 void
402 config::add_notify(int prio, event_proc *p)
403 {
404 	p->set_priority(prio);
405 	_notify_list.push_back(p);
406 }
407 
408 void
409 config::set_pidfile(const char *fn)
410 {
411 	_pidfile = string(fn);
412 }
413 
414 void
415 config::push_var_table()
416 {
417 	var_list *vl;
418 
419 	vl = new var_list();
420 	_var_list_table.push_back(vl);
421 	if (Dflag)
422 		fprintf(stderr, "Pushing table\n");
423 }
424 
425 void
426 config::pop_var_table()
427 {
428 	delete _var_list_table.back();
429 	_var_list_table.pop_back();
430 	if (Dflag)
431 		fprintf(stderr, "Popping table\n");
432 }
433 
434 void
435 config::set_variable(const char *var, const char *val)
436 {
437 	_var_list_table.back()->set_variable(var, val);
438 }
439 
440 const string &
441 config::get_variable(const string &var)
442 {
443 	vector<var_list *>::reverse_iterator i;
444 
445 	for (i = _var_list_table.rbegin(); i != _var_list_table.rend(); i++) {
446 		if ((*i)->is_set(var))
447 			return ((*i)->get_variable(var));
448 	}
449 	return (var_list::nothing);
450 }
451 
452 bool
453 config::is_id_char(char ch)
454 {
455 	return (ch != '\0' && (isalpha(ch) || isdigit(ch) || ch == '_' ||
456 	    ch == '-'));
457 }
458 
459 void
460 config::expand_one(const char *&src, string &dst)
461 {
462 	int count;
463 	string buffer, varstr;
464 
465 	src++;
466 	// $$ -> $
467 	if (*src == '$') {
468 		dst.append(src++, 1);
469 		return;
470 	}
471 
472 	// $(foo) -> $(foo)
473 	// Not sure if I want to support this or not, so for now we just pass
474 	// it through.
475 	if (*src == '(') {
476 		dst.append("$");
477 		count = 1;
478 		/* If the string ends before ) is matched , return. */
479 		while (count > 0 && *src) {
480 			if (*src == ')')
481 				count--;
482 			else if (*src == '(')
483 				count++;
484 			dst.append(src++, 1);
485 		}
486 		return;
487 	}
488 
489 	// ${^A-Za-z] -> $\1
490 	if (!isalpha(*src)) {
491 		dst.append("$");
492 		dst.append(src++, 1);
493 		return;
494 	}
495 
496 	// $var -> replace with value
497 	do {
498 		buffer.append(src++, 1);
499 	} while (is_id_char(*src));
500 	buffer.append("", 1);
501 	varstr = get_variable(buffer.c_str());
502 	dst.append(varstr);
503 }
504 
505 const string
506 config::expand_string(const string &s)
507 {
508 	const char *src;
509 	string dst;
510 
511 	src = s.c_str();
512 	while (*src) {
513 		if (*src == '$')
514 			expand_one(src, dst);
515 		else
516 			dst.append(src++, 1);
517 	}
518 	dst.append("", 1);
519 
520 	return (dst);
521 }
522 
523 bool
524 config::chop_var(char *&buffer, char *&lhs, char *&rhs)
525 {
526 	char *walker;
527 
528 	if (*buffer == '\0')
529 		return (false);
530 	walker = lhs = buffer;
531 	while (is_id_char(*walker))
532 		walker++;
533 	if (*walker != '=')
534 		return (false);
535 	walker++;		// skip =
536 	if (*walker == '"') {
537 		walker++;	// skip "
538 		rhs = walker;
539 		while (*walker && *walker != '"')
540 			walker++;
541 		if (*walker != '"')
542 			return (false);
543 		rhs[-2] = '\0';
544 		*walker++ = '\0';
545 	} else {
546 		rhs = walker;
547 		while (*walker && !isspace(*walker))
548 			walker++;
549 		if (*walker != '\0')
550 			*walker++ = '\0';
551 		rhs[-1] = '\0';
552 	}
553 	while (isspace(*walker))
554 		walker++;
555 	buffer = walker;
556 	return (true);
557 }
558 
559 
560 char *
561 config::set_vars(char *buffer)
562 {
563 	char *lhs;
564 	char *rhs;
565 
566 	while (1) {
567 		if (!chop_var(buffer, lhs, rhs))
568 			break;
569 		set_variable(lhs, rhs);
570 	}
571 	return (buffer);
572 }
573 
574 void
575 config::find_and_execute(char type)
576 {
577 	vector<event_proc *> *l;
578 	vector<event_proc *>::const_iterator i;
579 	const char *s;
580 
581 	switch (type) {
582 	default:
583 		return;
584 	case notify:
585 		l = &_notify_list;
586 		s = "notify";
587 		break;
588 	case nomatch:
589 		l = &_nomatch_list;
590 		s = "nomatch";
591 		break;
592 	case attach:
593 		l = &_attach_list;
594 		s = "attach";
595 		break;
596 	case detach:
597 		l = &_detach_list;
598 		s = "detach";
599 		break;
600 	}
601 	if (Dflag)
602 		fprintf(stderr, "Processing %s event\n", s);
603 	for (i = l->begin(); i != l->end(); i++) {
604 		if ((*i)->matches(*this)) {
605 			(*i)->run(*this);
606 			break;
607 		}
608 	}
609 
610 }
611 
612 
613 static void
614 process_event(char *buffer)
615 {
616 	char type;
617 	char *sp;
618 
619 	sp = buffer + 1;
620 	if (Dflag)
621 		fprintf(stderr, "Processing event '%s'\n", buffer);
622 	type = *buffer++;
623 	cfg.push_var_table();
624 	// No match doesn't have a device, and the format is a little
625 	// different, so handle it separately.
626 	switch (type) {
627 	case notify:
628 		sp = cfg.set_vars(sp);
629 		break;
630 	case nomatch:
631 		//? at location pnp-info on bus
632 		sp = strchr(sp, ' ');
633 		if (sp == NULL)
634 			return;	/* Can't happen? */
635 		*sp++ = '\0';
636 		if (strncmp(sp, "at ", 3) == 0)
637 			sp += 3;
638 		sp = cfg.set_vars(sp);
639 		if (strncmp(sp, "on ", 3) == 0)
640 			cfg.set_variable("bus", sp + 3);
641 		break;
642 	case attach:	/*FALLTHROUGH*/
643 	case detach:
644 		sp = strchr(sp, ' ');
645 		if (sp == NULL)
646 			return;	/* Can't happen? */
647 		*sp++ = '\0';
648 		cfg.set_variable("device-name", buffer);
649 		if (strncmp(sp, "at ", 3) == 0)
650 			sp += 3;
651 		sp = cfg.set_vars(sp);
652 		if (strncmp(sp, "on ", 3) == 0)
653 			cfg.set_variable("bus", sp + 3);
654 		break;
655 	}
656 
657 	cfg.find_and_execute(type);
658 	cfg.pop_var_table();
659 }
660 
661 int
662 create_socket(const char *name)
663 {
664 	int fd, slen;
665 	struct sockaddr_un sun;
666 
667 	if ((fd = socket(PF_LOCAL, SOCK_STREAM, 0)) < 0)
668 		err(1, "socket");
669 	bzero(&sun, sizeof(sun));
670 	sun.sun_family = AF_UNIX;
671 	strlcpy(sun.sun_path, name, sizeof(sun.sun_path));
672 	slen = SUN_LEN(&sun);
673 	unlink(name);
674 	if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
675 	    	err(1, "fcntl");
676 	if (bind(fd, (struct sockaddr *) & sun, slen) < 0)
677 		err(1, "bind");
678 	listen(fd, 4);
679 	chown(name, 0, 0);	/* XXX - root.wheel */
680 	chmod(name, 0666);
681 	return (fd);
682 }
683 
684 list<int> clients;
685 
686 void
687 notify_clients(const char *data, int len)
688 {
689 	list<int> bad;
690 	list<int>::const_iterator i;
691 
692 	for (i = clients.begin(); i != clients.end(); i++) {
693 		if (write(*i, data, len) <= 0) {
694 			bad.push_back(*i);
695 			close(*i);
696 		}
697 	}
698 
699 	for (i = bad.begin(); i != bad.end(); i++)
700 		clients.erase(find(clients.begin(), clients.end(), *i));
701 }
702 
703 void
704 new_client(int fd)
705 {
706 	int s;
707 
708 	s = accept(fd, NULL, NULL);
709 	if (s != -1)
710 		clients.push_back(s);
711 }
712 
713 static void
714 event_loop(void)
715 {
716 	int rv;
717 	int fd;
718 	char buffer[DEVCTL_MAXBUF];
719 	int once = 0;
720 	int server_fd, max_fd;
721 	timeval tv;
722 	fd_set fds;
723 
724 	fd = open(PATH_DEVCTL, O_RDONLY);
725 	if (fd == -1)
726 		err(1, "Can't open devctl device %s", PATH_DEVCTL);
727 	if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0)
728 		err(1, "Can't set close-on-exec flag on devctl");
729 	server_fd = create_socket(PIPE);
730 	max_fd = max(fd, server_fd) + 1;
731 	while (1) {
732 		if (romeo_must_die)
733 			break;
734 		if (!once && !dflag && !nflag) {
735 			// Check to see if we have any events pending.
736 			tv.tv_sec = 0;
737 			tv.tv_usec = 0;
738 			FD_ZERO(&fds);
739 			FD_SET(fd, &fds);
740 			rv = select(fd + 1, &fds, NULL, NULL, &tv);
741 			// No events -> we've processed all pending events
742 			if (rv == 0) {
743 				if (Dflag)
744 					fprintf(stderr, "Calling daemon\n");
745 				daemon(0, 0);
746 				cfg.open_pidfile();
747 				once++;
748 			}
749 		}
750 		FD_ZERO(&fds);
751 		FD_SET(fd, &fds);
752 		FD_SET(server_fd, &fds);
753 		rv = select(max_fd, &fds, NULL, NULL, NULL);
754 		if (rv == -1) {
755 			if (errno == EINTR)
756 				continue;
757 			err(1, "select");
758 		}
759 		if (FD_ISSET(fd, &fds)) {
760 			rv = read(fd, buffer, sizeof(buffer) - 1);
761 			if (rv > 0) {
762 				notify_clients(buffer, rv);
763 				buffer[rv] = '\0';
764 				while (buffer[--rv] == '\n')
765 					buffer[rv] = '\0';
766 				process_event(buffer);
767 			} else if (rv < 0) {
768 				if (errno != EINTR)
769 					break;
770 			} else {
771 				/* EOF */
772 				break;
773 			}
774 		}
775 		if (FD_ISSET(server_fd, &fds))
776 			new_client(server_fd);
777 	}
778 	close(fd);
779 }
780 
781 /*
782  * functions that the parser uses.
783  */
784 void
785 add_attach(int prio, event_proc *p)
786 {
787 	cfg.add_attach(prio, p);
788 }
789 
790 void
791 add_detach(int prio, event_proc *p)
792 {
793 	cfg.add_detach(prio, p);
794 }
795 
796 void
797 add_directory(const char *dir)
798 {
799 	cfg.add_directory(dir);
800 	free(const_cast<char *>(dir));
801 }
802 
803 void
804 add_nomatch(int prio, event_proc *p)
805 {
806 	cfg.add_nomatch(prio, p);
807 }
808 
809 void
810 add_notify(int prio, event_proc *p)
811 {
812 	cfg.add_notify(prio, p);
813 }
814 
815 event_proc *
816 add_to_event_proc(event_proc *ep, eps *eps)
817 {
818 	if (ep == NULL)
819 		ep = new event_proc();
820 	ep->add(eps);
821 	return (ep);
822 }
823 
824 eps *
825 new_action(const char *cmd)
826 {
827 	eps *e = new action(cmd);
828 	free(const_cast<char *>(cmd));
829 	return (e);
830 }
831 
832 eps *
833 new_match(const char *var, const char *re)
834 {
835 	eps *e = new match(cfg, var, re);
836 	free(const_cast<char *>(var));
837 	free(const_cast<char *>(re));
838 	return (e);
839 }
840 
841 eps *
842 new_media(const char *var, const char *re)
843 {
844 	eps *e = new media(cfg, var, re);
845 	free(const_cast<char *>(var));
846 	free(const_cast<char *>(re));
847 	return (e);
848 }
849 
850 void
851 set_pidfile(const char *name)
852 {
853 	cfg.set_pidfile(name);
854 	free(const_cast<char *>(name));
855 }
856 
857 void
858 set_variable(const char *var, const char *val)
859 {
860 	cfg.set_variable(var, val);
861 	free(const_cast<char *>(var));
862 	free(const_cast<char *>(val));
863 }
864 
865 
866 
867 static void
868 gensighand(int)
869 {
870 	romeo_must_die++;
871 	unlink("/var/run/devd.pid");	/* XXX */
872 	_exit(0);
873 }
874 
875 static void
876 usage()
877 {
878 	fprintf(stderr, "usage: %s [-Ddn] [-f file]\n", getprogname());
879 	exit(1);
880 }
881 
882 static void
883 check_devd_enabled()
884 {
885 	int val = 0;
886 	size_t len;
887 
888 	len = sizeof(val);
889 	if (sysctlbyname(SYSCTL, &val, &len, NULL, 0) != 0)
890 		errx(1, "devctl sysctl missing from kernel!");
891 	if (val) {
892 		warnx("Setting " SYSCTL " to 0");
893 		val = 0;
894 		sysctlbyname(SYSCTL, NULL, NULL, &val, sizeof(val));
895 	}
896 }
897 
898 /*
899  * main
900  */
901 int
902 main(int argc, char **argv)
903 {
904 	int ch;
905 
906 	check_devd_enabled();
907 	while ((ch = getopt(argc, argv, "Ddf:n")) != -1) {
908 		switch (ch) {
909 		case 'D':
910 			Dflag++;
911 			break;
912 		case 'd':
913 			dflag++;
914 			break;
915 		case 'f':
916 			configfile = optarg;
917 			break;
918 		case 'n':
919 			nflag++;
920 			break;
921 		default:
922 			usage();
923 		}
924 	}
925 
926 	cfg.parse();
927 	if (!dflag && nflag) {
928 		if (Dflag)
929 			fprintf(stderr, "Calling daemon\n");
930 		daemon(0, 0);
931 		cfg.open_pidfile();
932 	}
933 	signal(SIGPIPE, SIG_IGN);
934 	signal(SIGHUP, gensighand);
935 	signal(SIGINT, gensighand);
936 	signal(SIGTERM, gensighand);
937 	event_loop();
938 	return (0);
939 }
940