sbin/devd/devd.cc

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