1/* dnsmasq is Copyright (c) 2000-2015 Simon Kelley 2 3 This program is free software; you can redistribute it and/or modify 4 it under the terms of the GNU General Public License as published by 5 the Free Software Foundation; version 2 dated June, 1991, or 6 (at your option) version 3 dated 29 June, 2007. 7 8 This program is distributed in the hope that it will be useful, 9 but WITHOUT ANY WARRANTY; without even the implied warranty of 10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 GNU General Public License for more details. 12 13 You should have received a copy of the GNU General Public License 14 along with this program. If not, see <http://www.gnu.org/licenses/>. 15*/ 16 17/* Declare static char *compiler_opts in config.h */ 18#define DNSMASQ_COMPILE_OPTS 19 20#include "dnsmasq.h" 21 22struct daemon *daemon; 23 24static volatile pid_t pid = 0; 25static volatile int pipewrite; 26 27static int set_dns_listeners(time_t now); 28static void check_dns_listeners(time_t now); 29static void sig_handler(int sig); 30static void async_event(int pipe, time_t now); 31static void fatal_event(struct event_desc *ev, char *msg); 32static int read_event(int fd, struct event_desc *evp, char **msg); 33static void poll_resolv(int force, int do_reload, time_t now); 34 35int main (int argc, char **argv) 36{ 37 int bind_fallback = 0; 38 time_t now; 39 struct sigaction sigact; 40 struct iname *if_tmp; 41 int piperead, pipefd[2], err_pipe[2]; 42 struct passwd *ent_pw = NULL; 43#if defined(HAVE_SCRIPT) 44 uid_t script_uid = 0; 45 gid_t script_gid = 0; 46#endif 47 struct group *gp = NULL; 48 long i, max_fd = sysconf(_SC_OPEN_MAX); 49 char *baduser = NULL; 50 int log_err; 51#if defined(HAVE_LINUX_NETWORK) 52 cap_user_header_t hdr = NULL; 53 cap_user_data_t data = NULL; 54 char *bound_device = NULL; 55 int did_bind = 0; 56#endif 57#if defined(HAVE_DHCP) || defined(HAVE_DHCP6) 58 struct dhcp_context *context; 59 struct dhcp_relay *relay; 60#endif 61#ifdef HAVE_TFTP 62 int tftp_prefix_missing = 0; 63#endif 64 65#ifdef LOCALEDIR 66 setlocale(LC_ALL, ""); 67 bindtextdomain("dnsmasq", LOCALEDIR); 68 textdomain("dnsmasq"); 69#endif 70 71 sigact.sa_handler = sig_handler; 72 sigact.sa_flags = 0; 73 sigemptyset(&sigact.sa_mask); 74 sigaction(SIGUSR1, &sigact, NULL); 75 sigaction(SIGUSR2, &sigact, NULL); 76 sigaction(SIGHUP, &sigact, NULL); 77 sigaction(SIGTERM, &sigact, NULL); 78 sigaction(SIGALRM, &sigact, NULL); 79 sigaction(SIGCHLD, &sigact, NULL); 80 81 /* ignore SIGPIPE */ 82 sigact.sa_handler = SIG_IGN; 83 sigaction(SIGPIPE, &sigact, NULL); 84 85 umask(022); /* known umask, create leases and pid files as 0644 */ 86 87 rand_init(); /* Must precede read_opts() */ 88 89 read_opts(argc, argv, compile_opts); 90 91 if (daemon->edns_pktsz < PACKETSZ) 92 daemon->edns_pktsz = PACKETSZ; 93 94 daemon->packet_buff_sz = daemon->edns_pktsz > DNSMASQ_PACKETSZ ? 95 daemon->edns_pktsz : DNSMASQ_PACKETSZ; 96 daemon->packet = safe_malloc(daemon->packet_buff_sz); 97 98 daemon->addrbuff = safe_malloc(ADDRSTRLEN); 99 if (option_bool(OPT_EXTRALOG)) 100 daemon->addrbuff2 = safe_malloc(ADDRSTRLEN); 101 102#ifdef HAVE_DNSSEC 103 if (option_bool(OPT_DNSSEC_VALID)) 104 { 105 /* Note that both /000 and '.' are allowed within labels. These get 106 represented in presentation format using NAME_ESCAPE as an escape 107 character when in DNSSEC mode. 108 In theory, if all the characters in a name were /000 or 109 '.' or NAME_ESCAPE then all would have to be escaped, so the 110 presentation format would be twice as long as the spec. 111 112 daemon->namebuff was previously allocated by the option-reading 113 code before we knew if we're in DNSSEC mode, so reallocate here. */ 114 free(daemon->namebuff); 115 daemon->namebuff = safe_malloc(MAXDNAME * 2); 116 daemon->keyname = safe_malloc(MAXDNAME * 2); 117 daemon->workspacename = safe_malloc(MAXDNAME * 2); 118 } 119#endif 120 121#ifdef HAVE_DHCP 122 if (!daemon->lease_file) 123 { 124 if (daemon->dhcp || daemon->dhcp6) 125 daemon->lease_file = LEASEFILE; 126 } 127#endif 128 129 /* Close any file descriptors we inherited apart from std{in|out|err} 130 131 Ensure that at least stdin, stdout and stderr (fd 0, 1, 2) exist, 132 otherwise file descriptors we create can end up being 0, 1, or 2 133 and then get accidentally closed later when we make 0, 1, and 2 134 open to /dev/null. Normally we'll be started with 0, 1 and 2 open, 135 but it's not guaranteed. By opening /dev/null three times, we 136 ensure that we're not using those fds for real stuff. */ 137 for (i = 0; i < max_fd; i++) 138 if (i != STDOUT_FILENO && i != STDERR_FILENO && i != STDIN_FILENO) 139 close(i); 140 else 141 open("/dev/null", O_RDWR); 142 143#ifndef HAVE_LINUX_NETWORK 144# if !(defined(IP_RECVDSTADDR) && defined(IP_RECVIF) && defined(IP_SENDSRCADDR)) 145 if (!option_bool(OPT_NOWILD)) 146 { 147 bind_fallback = 1; 148 set_option_bool(OPT_NOWILD); 149 } 150# endif 151 152 /* -- bind-dynamic not supported on !Linux, fall back to --bind-interfaces */ 153 if (option_bool(OPT_CLEVERBIND)) 154 { 155 bind_fallback = 1; 156 set_option_bool(OPT_NOWILD); 157 reset_option_bool(OPT_CLEVERBIND); 158 } 159#endif 160 161#ifndef HAVE_INOTIFY 162 if (daemon->dynamic_dirs) 163 die(_("dhcp-hostsdir, dhcp-optsdir and hostsdir are not supported on this platform"), NULL, EC_BADCONF); 164#endif 165 166 if (option_bool(OPT_DNSSEC_VALID)) 167 { 168#ifdef HAVE_DNSSEC 169 if (!daemon->ds) 170 die(_("no trust anchors provided for DNSSEC"), NULL, EC_BADCONF); 171 172 if (daemon->cachesize < CACHESIZ) 173 die(_("cannot reduce cache size from default when DNSSEC enabled"), NULL, EC_BADCONF); 174#else 175 die(_("DNSSEC not available: set HAVE_DNSSEC in src/config.h"), NULL, EC_BADCONF); 176#endif 177 } 178 179#ifndef HAVE_TFTP 180 if (option_bool(OPT_TFTP)) 181 die(_("TFTP server not available: set HAVE_TFTP in src/config.h"), NULL, EC_BADCONF); 182#endif 183 184#ifdef HAVE_CONNTRACK 185 if (option_bool(OPT_CONNTRACK) && (daemon->query_port != 0 || daemon->osport)) 186 die (_("cannot use --conntrack AND --query-port"), NULL, EC_BADCONF); 187#else 188 if (option_bool(OPT_CONNTRACK)) 189 die(_("conntrack support not available: set HAVE_CONNTRACK in src/config.h"), NULL, EC_BADCONF); 190#endif 191 192#ifdef HAVE_SOLARIS_NETWORK 193 if (daemon->max_logs != 0) 194 die(_("asychronous logging is not available under Solaris"), NULL, EC_BADCONF); 195#endif 196 197#ifdef __ANDROID__ 198 if (daemon->max_logs != 0) 199 die(_("asychronous logging is not available under Android"), NULL, EC_BADCONF); 200#endif 201 202#ifndef HAVE_AUTH 203 if (daemon->authserver) 204 die(_("authoritative DNS not available: set HAVE_AUTH in src/config.h"), NULL, EC_BADCONF); 205#endif 206 207#ifndef HAVE_LOOP 208 if (option_bool(OPT_LOOP_DETECT)) 209 die(_("loop detection not available: set HAVE_LOOP in src/config.h"), NULL, EC_BADCONF); 210#endif 211 212 now = dnsmasq_time(); 213 214 /* Create a serial at startup if not configured. */ 215 if (daemon->authinterface && daemon->soa_sn == 0) 216#ifdef HAVE_BROKEN_RTC 217 die(_("zone serial must be configured in --auth-soa"), NULL, EC_BADCONF); 218#else 219 daemon->soa_sn = now; 220#endif 221 222#ifdef HAVE_DHCP6 223 if (daemon->dhcp6) 224 { 225 daemon->doing_ra = option_bool(OPT_RA); 226 227 for (context = daemon->dhcp6; context; context = context->next) 228 { 229 if (context->flags & CONTEXT_DHCP) 230 daemon->doing_dhcp6 = 1; 231 if (context->flags & CONTEXT_RA) 232 daemon->doing_ra = 1; 233#if !defined(HAVE_LINUX_NETWORK) && !defined(HAVE_BSD_NETWORK) 234 if (context->flags & CONTEXT_TEMPLATE) 235 die (_("dhcp-range constructor not available on this platform"), NULL, EC_BADCONF); 236#endif 237 } 238 } 239#endif 240 241#ifdef HAVE_DHCP 242 /* Note that order matters here, we must call lease_init before 243 creating any file descriptors which shouldn't be leaked 244 to the lease-script init process. We need to call common_init 245 before lease_init to allocate buffers it uses.*/ 246 if (daemon->dhcp || daemon->doing_dhcp6 || daemon->relay4 || daemon->relay6) 247 { 248 dhcp_common_init(); 249 if (daemon->dhcp || daemon->doing_dhcp6) 250 lease_init(now); 251 } 252 253 if (daemon->dhcp || daemon->relay4) 254 dhcp_init(); 255 256# ifdef HAVE_DHCP6 257 if (daemon->doing_ra || daemon->doing_dhcp6 || daemon->relay6) 258 ra_init(now); 259 260 if (daemon->doing_dhcp6 || daemon->relay6) 261 dhcp6_init(); 262# endif 263 264#endif 265 266#ifdef HAVE_IPSET 267 if (daemon->ipsets) 268 ipset_init(); 269#endif 270 271#if defined(HAVE_LINUX_NETWORK) 272 netlink_init(); 273#elif defined(HAVE_BSD_NETWORK) 274 route_init(); 275#endif 276 277 if (option_bool(OPT_NOWILD) && option_bool(OPT_CLEVERBIND)) 278 die(_("cannot set --bind-interfaces and --bind-dynamic"), NULL, EC_BADCONF); 279 280 if (!enumerate_interfaces(1) || !enumerate_interfaces(0)) 281 die(_("failed to find list of interfaces: %s"), NULL, EC_MISC); 282 283 if (option_bool(OPT_NOWILD) || option_bool(OPT_CLEVERBIND)) 284 { 285 create_bound_listeners(1); 286 287 if (!option_bool(OPT_CLEVERBIND)) 288 for (if_tmp = daemon->if_names; if_tmp; if_tmp = if_tmp->next) 289 if (if_tmp->name && !if_tmp->used) 290 die(_("unknown interface %s"), if_tmp->name, EC_BADNET); 291 292#if defined(HAVE_LINUX_NETWORK) && defined(HAVE_DHCP) 293 /* after enumerate_interfaces() */ 294 bound_device = whichdevice(); 295 296 if (daemon->dhcp) 297 { 298 if (!daemon->relay4 && bound_device) 299 { 300 bindtodevice(bound_device, daemon->dhcpfd); 301 did_bind = 1; 302 } 303 if (daemon->enable_pxe && bound_device) 304 { 305 bindtodevice(bound_device, daemon->pxefd); 306 did_bind = 1; 307 } 308 } 309#endif 310 311#if defined(HAVE_LINUX_NETWORK) && defined(HAVE_DHCP6) 312 if (daemon->doing_dhcp6 && !daemon->relay6 && bound_device) 313 { 314 bindtodevice(bound_device, daemon->dhcp6fd); 315 did_bind = 1; 316 } 317#endif 318 } 319 else 320 create_wildcard_listeners(); 321 322#ifdef HAVE_DHCP6 323 /* after enumerate_interfaces() */ 324 if (daemon->doing_dhcp6 || daemon->relay6 || daemon->doing_ra) 325 join_multicast(1); 326 327 /* After netlink_init() and before create_helper() */ 328 lease_make_duid(now); 329#endif 330 331 if (daemon->port != 0) 332 { 333 cache_init(); 334 335#ifdef HAVE_DNSSEC 336 blockdata_init(); 337#endif 338 } 339 340#ifdef HAVE_INOTIFY 341 if (daemon->port != 0 || daemon->dhcp || daemon->doing_dhcp6) 342 inotify_dnsmasq_init(); 343 else 344 daemon->inotifyfd = -1; 345#endif 346 347 if (option_bool(OPT_DBUS)) 348#ifdef HAVE_DBUS 349 { 350 char *err; 351 daemon->dbus = NULL; 352 daemon->watches = NULL; 353 if ((err = dbus_init())) 354 die(_("DBus error: %s"), err, EC_MISC); 355 } 356#else 357 die(_("DBus not available: set HAVE_DBUS in src/config.h"), NULL, EC_BADCONF); 358#endif 359 360 if (daemon->port != 0) 361 pre_allocate_sfds(); 362 363#if defined(HAVE_SCRIPT) 364 /* Note getpwnam returns static storage */ 365 if ((daemon->dhcp || daemon->dhcp6) && 366 daemon->scriptuser && 367 (daemon->lease_change_command || daemon->luascript)) 368 { 369 if ((ent_pw = getpwnam(daemon->scriptuser))) 370 { 371 script_uid = ent_pw->pw_uid; 372 script_gid = ent_pw->pw_gid; 373 } 374 else 375 baduser = daemon->scriptuser; 376 } 377#endif 378 379 if (daemon->username && !(ent_pw = getpwnam(daemon->username))) 380 baduser = daemon->username; 381 else if (daemon->groupname && !(gp = getgrnam(daemon->groupname))) 382 baduser = daemon->groupname; 383 384 if (baduser) 385 die(_("unknown user or group: %s"), baduser, EC_BADCONF); 386 387 /* implement group defaults, "dip" if available, or group associated with uid */ 388 if (!daemon->group_set && !gp) 389 { 390 if (!(gp = getgrnam(CHGRP)) && ent_pw) 391 gp = getgrgid(ent_pw->pw_gid); 392 393 /* for error message */ 394 if (gp) 395 daemon->groupname = gp->gr_name; 396 } 397 398#if defined(HAVE_LINUX_NETWORK) 399 /* determine capability API version here, while we can still 400 call safe_malloc */ 401 if (ent_pw && ent_pw->pw_uid != 0) 402 { 403 int capsize = 1; /* for header version 1 */ 404 hdr = safe_malloc(sizeof(*hdr)); 405 406 /* find version supported by kernel */ 407 memset(hdr, 0, sizeof(*hdr)); 408 capget(hdr, NULL); 409 410 if (hdr->version != LINUX_CAPABILITY_VERSION_1) 411 { 412 /* if unknown version, use largest supported version (3) */ 413 if (hdr->version != LINUX_CAPABILITY_VERSION_2) 414 hdr->version = LINUX_CAPABILITY_VERSION_3; 415 capsize = 2; 416 } 417 418 data = safe_malloc(sizeof(*data) * capsize); 419 memset(data, 0, sizeof(*data) * capsize); 420 } 421#endif 422 423 /* Use a pipe to carry signals and other events back to the event loop 424 in a race-free manner and another to carry errors to daemon-invoking process */ 425 safe_pipe(pipefd, 1); 426 427 piperead = pipefd[0]; 428 pipewrite = pipefd[1]; 429 /* prime the pipe to load stuff first time. */ 430 send_event(pipewrite, EVENT_INIT, 0, NULL); 431 432 err_pipe[1] = -1; 433 434 if (!option_bool(OPT_DEBUG)) 435 { 436 /* The following code "daemonizes" the process. 437 See Stevens section 12.4 */ 438 439 if (chdir("/") != 0) 440 die(_("cannot chdir to filesystem root: %s"), NULL, EC_MISC); 441 442#ifndef NO_FORK 443 if (!option_bool(OPT_NO_FORK)) 444 { 445 pid_t pid; 446 447 /* pipe to carry errors back to original process. 448 When startup is complete we close this and the process terminates. */ 449 safe_pipe(err_pipe, 0); 450 451 if ((pid = fork()) == -1) 452 /* fd == -1 since we've not forked, never returns. */ 453 send_event(-1, EVENT_FORK_ERR, errno, NULL); 454 455 if (pid != 0) 456 { 457 struct event_desc ev; 458 char *msg; 459 460 /* close our copy of write-end */ 461 while (retry_send(close(err_pipe[1]))); 462 463 /* check for errors after the fork */ 464 if (read_event(err_pipe[0], &ev, &msg)) 465 fatal_event(&ev, msg); 466 467 _exit(EC_GOOD); 468 } 469 470 while (retry_send(close(err_pipe[0]))); 471 472 /* NO calls to die() from here on. */ 473 474 setsid(); 475 476 if ((pid = fork()) == -1) 477 send_event(err_pipe[1], EVENT_FORK_ERR, errno, NULL); 478 479 if (pid != 0) 480 _exit(0); 481 } 482#endif 483 484 /* write pidfile _after_ forking ! */ 485 if (daemon->runfile) 486 { 487 int fd, err = 0; 488 489 sprintf(daemon->namebuff, "%d\n", (int) getpid()); 490 491 /* Explanation: Some installations of dnsmasq (eg Debian/Ubuntu) locate the pid-file 492 in a directory which is writable by the non-privileged user that dnsmasq runs as. This 493 allows the daemon to delete the file as part of its shutdown. This is a security hole to the 494 extent that an attacker running as the unprivileged user could replace the pidfile with a 495 symlink, and have the target of that symlink overwritten as root next time dnsmasq starts. 496 497 The folowing code first deletes any existing file, and then opens it with the O_EXCL flag, 498 ensuring that the open() fails should there be any existing file (because the unlink() failed, 499 or an attacker exploited the race between unlink() and open()). This ensures that no symlink 500 attack can succeed. 501 502 Any compromise of the non-privileged user still theoretically allows the pid-file to be 503 replaced whilst dnsmasq is running. The worst that could allow is that the usual 504 "shutdown dnsmasq" shell command could be tricked into stopping any other process. 505 506 Note that if dnsmasq is started as non-root (eg for testing) it silently ignores 507 failure to write the pid-file. 508 */ 509 510 unlink(daemon->runfile); 511 512 if ((fd = open(daemon->runfile, O_WRONLY|O_CREAT|O_TRUNC|O_EXCL, S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH)) == -1) 513 { 514 /* only complain if started as root */ 515 if (getuid() == 0) 516 err = 1; 517 } 518 else 519 { 520 if (!read_write(fd, (unsigned char *)daemon->namebuff, strlen(daemon->namebuff), 0)) 521 err = 1; 522 else 523 { 524 while (retry_send(close(fd))); 525 if (errno != 0) 526 err = 1; 527 } 528 } 529 530 if (err) 531 { 532 send_event(err_pipe[1], EVENT_PIDFILE, errno, daemon->runfile); 533 _exit(0); 534 } 535 } 536 } 537 538 log_err = log_start(ent_pw, err_pipe[1]); 539 540 if (!option_bool(OPT_DEBUG)) 541 { 542 /* open stdout etc to /dev/null */ 543 int nullfd = open("/dev/null", O_RDWR); 544 dup2(nullfd, STDOUT_FILENO); 545 dup2(nullfd, STDERR_FILENO); 546 dup2(nullfd, STDIN_FILENO); 547 close(nullfd); 548 } 549 550 /* if we are to run scripts, we need to fork a helper before dropping root. */ 551 daemon->helperfd = -1; 552#ifdef HAVE_SCRIPT 553 if ((daemon->dhcp || daemon->dhcp6) && (daemon->lease_change_command || daemon->luascript)) 554 daemon->helperfd = create_helper(pipewrite, err_pipe[1], script_uid, script_gid, max_fd); 555#endif 556 557 if (!option_bool(OPT_DEBUG) && getuid() == 0) 558 { 559 int bad_capabilities = 0; 560 gid_t dummy; 561 562 /* remove all supplimentary groups */ 563 if (gp && 564 (setgroups(0, &dummy) == -1 || 565 setgid(gp->gr_gid) == -1)) 566 { 567 send_event(err_pipe[1], EVENT_GROUP_ERR, errno, daemon->groupname); 568 _exit(0); 569 } 570 571 if (ent_pw && ent_pw->pw_uid != 0) 572 { 573#if defined(HAVE_LINUX_NETWORK) 574 /* On linux, we keep CAP_NETADMIN (for ARP-injection) and 575 CAP_NET_RAW (for icmp) if we're doing dhcp. If we have yet to bind 576 ports because of DAD, or we're doing it dynamically, 577 we need CAP_NET_BIND_SERVICE too. */ 578 if (is_dad_listeners() || option_bool(OPT_CLEVERBIND)) 579 data->effective = data->permitted = data->inheritable = 580 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) | 581 (1 << CAP_SETUID) | (1 << CAP_NET_BIND_SERVICE); 582 else 583 data->effective = data->permitted = data->inheritable = 584 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) | (1 << CAP_SETUID); 585 586 /* Tell kernel to not clear capabilities when dropping root */ 587 if (capset(hdr, data) == -1 || prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1) 588 bad_capabilities = errno; 589 590#elif defined(HAVE_SOLARIS_NETWORK) 591 /* http://developers.sun.com/solaris/articles/program_privileges.html */ 592 priv_set_t *priv_set; 593 594 if (!(priv_set = priv_str_to_set("basic", ",", NULL)) || 595 priv_addset(priv_set, PRIV_NET_ICMPACCESS) == -1 || 596 priv_addset(priv_set, PRIV_SYS_NET_CONFIG) == -1) 597 bad_capabilities = errno; 598 599 if (priv_set && bad_capabilities == 0) 600 { 601 priv_inverse(priv_set); 602 603 if (setppriv(PRIV_OFF, PRIV_LIMIT, priv_set) == -1) 604 bad_capabilities = errno; 605 } 606 607 if (priv_set) 608 priv_freeset(priv_set); 609 610#endif 611 612 if (bad_capabilities != 0) 613 { 614 send_event(err_pipe[1], EVENT_CAP_ERR, bad_capabilities, NULL); 615 _exit(0); 616 } 617 618 /* finally drop root */ 619 if (setuid(ent_pw->pw_uid) == -1) 620 { 621 send_event(err_pipe[1], EVENT_USER_ERR, errno, daemon->username); 622 _exit(0); 623 } 624 625#ifdef HAVE_LINUX_NETWORK 626 if (is_dad_listeners() || option_bool(OPT_CLEVERBIND)) 627 data->effective = data->permitted = 628 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) | (1 << CAP_NET_BIND_SERVICE); 629 else 630 data->effective = data->permitted = 631 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW); 632 data->inheritable = 0; 633 634 /* lose the setuid and setgid capbilities */ 635 if (capset(hdr, data) == -1) 636 { 637 send_event(err_pipe[1], EVENT_CAP_ERR, errno, NULL); 638 _exit(0); 639 } 640#endif 641 642 } 643 } 644 645#ifdef HAVE_LINUX_NETWORK 646 free(hdr); 647 free(data); 648 if (option_bool(OPT_DEBUG)) 649 prctl(PR_SET_DUMPABLE, 1, 0, 0, 0); 650#endif 651 652#ifdef HAVE_TFTP 653 if (option_bool(OPT_TFTP)) 654 { 655 DIR *dir; 656 struct tftp_prefix *p; 657 658 if (daemon->tftp_prefix) 659 { 660 if (!((dir = opendir(daemon->tftp_prefix)))) 661 { 662 tftp_prefix_missing = 1; 663 if (!option_bool(OPT_TFTP_NO_FAIL)) 664 { 665 send_event(err_pipe[1], EVENT_TFTP_ERR, errno, daemon->tftp_prefix); 666 _exit(0); 667 } 668 } 669 else 670 closedir(dir); 671 } 672 673 for (p = daemon->if_prefix; p; p = p->next) 674 { 675 p->missing = 0; 676 if (!((dir = opendir(p->prefix)))) 677 { 678 p->missing = 1; 679 if (!option_bool(OPT_TFTP_NO_FAIL)) 680 { 681 send_event(err_pipe[1], EVENT_TFTP_ERR, errno, p->prefix); 682 _exit(0); 683 } 684 } 685 else 686 closedir(dir); 687 } 688 } 689#endif 690 691 if (daemon->port == 0) 692 my_syslog(LOG_INFO, _("started, version %s DNS disabled"), VERSION); 693 else if (daemon->cachesize != 0) 694 my_syslog(LOG_INFO, _("started, version %s cachesize %d"), VERSION, daemon->cachesize); 695 else 696 my_syslog(LOG_INFO, _("started, version %s cache disabled"), VERSION); 697 698 my_syslog(LOG_DEBUG, _("compile time options: %s"), compile_opts); 699 700#ifdef HAVE_DBUS 701 if (option_bool(OPT_DBUS)) 702 { 703 if (daemon->dbus) 704 my_syslog(LOG_INFO, _("DBus support enabled: connected to system bus")); 705 else 706 my_syslog(LOG_INFO, _("DBus support enabled: bus connection pending")); 707 } 708#endif 709 710 if (option_bool(OPT_LOCAL_SERVICE)) 711 my_syslog(LOG_INFO, _("DNS service limited to local subnets")); 712 713#ifdef HAVE_DNSSEC 714 if (option_bool(OPT_DNSSEC_VALID)) 715 { 716 int rc; 717 718 /* Delay creating the timestamp file until here, after we've changed user, so that 719 it has the correct owner to allow updating the mtime later. 720 This means we have to report fatal errors via the pipe. */ 721 if ((rc = setup_timestamp()) == -1) 722 { 723 send_event(err_pipe[1], EVENT_TIME_ERR, errno, daemon->timestamp_file); 724 _exit(0); 725 } 726 727 my_syslog(LOG_INFO, _("DNSSEC validation enabled")); 728 729 if (option_bool(OPT_DNSSEC_TIME)) 730 my_syslog(LOG_INFO, _("DNSSEC signature timestamps not checked until first cache reload")); 731 732 if (rc == 1) 733 my_syslog(LOG_INFO, _("DNSSEC signature timestamps not checked until system time valid")); 734 } 735#endif 736 737 if (log_err != 0) 738 my_syslog(LOG_WARNING, _("warning: failed to change owner of %s: %s"), 739 daemon->log_file, strerror(log_err)); 740 741 if (bind_fallback) 742 my_syslog(LOG_WARNING, _("setting --bind-interfaces option because of OS limitations")); 743 744 if (option_bool(OPT_NOWILD)) 745 warn_bound_listeners(); 746 747 warn_int_names(); 748 749 if (!option_bool(OPT_NOWILD)) 750 for (if_tmp = daemon->if_names; if_tmp; if_tmp = if_tmp->next) 751 if (if_tmp->name && !if_tmp->used) 752 my_syslog(LOG_WARNING, _("warning: interface %s does not currently exist"), if_tmp->name); 753 754 if (daemon->port != 0 && option_bool(OPT_NO_RESOLV)) 755 { 756 if (daemon->resolv_files && !daemon->resolv_files->is_default) 757 my_syslog(LOG_WARNING, _("warning: ignoring resolv-file flag because no-resolv is set")); 758 daemon->resolv_files = NULL; 759 if (!daemon->servers) 760 my_syslog(LOG_WARNING, _("warning: no upstream servers configured")); 761 } 762 763 if (daemon->max_logs != 0) 764 my_syslog(LOG_INFO, _("asynchronous logging enabled, queue limit is %d messages"), daemon->max_logs); 765 766 767#ifdef HAVE_DHCP 768 for (context = daemon->dhcp; context; context = context->next) 769 log_context(AF_INET, context); 770 771 for (relay = daemon->relay4; relay; relay = relay->next) 772 log_relay(AF_INET, relay); 773 774# ifdef HAVE_DHCP6 775 for (context = daemon->dhcp6; context; context = context->next) 776 log_context(AF_INET6, context); 777 778 for (relay = daemon->relay6; relay; relay = relay->next) 779 log_relay(AF_INET6, relay); 780 781 if (daemon->doing_dhcp6 || daemon->doing_ra) 782 dhcp_construct_contexts(now); 783 784 if (option_bool(OPT_RA)) 785 my_syslog(MS_DHCP | LOG_INFO, _("IPv6 router advertisement enabled")); 786# endif 787 788# ifdef HAVE_LINUX_NETWORK 789 if (did_bind) 790 my_syslog(MS_DHCP | LOG_INFO, _("DHCP, sockets bound exclusively to interface %s"), bound_device); 791# endif 792 793 /* after dhcp_contruct_contexts */ 794 if (daemon->dhcp || daemon->doing_dhcp6) 795 lease_find_interfaces(now); 796#endif 797 798#ifdef HAVE_TFTP 799 if (option_bool(OPT_TFTP)) 800 { 801 struct tftp_prefix *p; 802 803 my_syslog(MS_TFTP | LOG_INFO, "TFTP %s%s %s", 804 daemon->tftp_prefix ? _("root is ") : _("enabled"), 805 daemon->tftp_prefix ? daemon->tftp_prefix: "", 806 option_bool(OPT_TFTP_SECURE) ? _("secure mode") : ""); 807 808 if (tftp_prefix_missing) 809 my_syslog(MS_TFTP | LOG_WARNING, _("warning: %s inaccessible"), daemon->tftp_prefix); 810 811 for (p = daemon->if_prefix; p; p = p->next) 812 if (p->missing) 813 my_syslog(MS_TFTP | LOG_WARNING, _("warning: TFTP directory %s inaccessible"), p->prefix); 814 815 /* This is a guess, it assumes that for small limits, 816 disjoint files might be served, but for large limits, 817 a single file will be sent to may clients (the file only needs 818 one fd). */ 819 820 max_fd -= 30; /* use other than TFTP */ 821 822 if (max_fd < 0) 823 max_fd = 5; 824 else if (max_fd < 100) 825 max_fd = max_fd/2; 826 else 827 max_fd = max_fd - 20; 828 829 /* if we have to use a limited range of ports, 830 that will limit the number of transfers */ 831 if (daemon->start_tftp_port != 0 && 832 daemon->end_tftp_port - daemon->start_tftp_port + 1 < max_fd) 833 max_fd = daemon->end_tftp_port - daemon->start_tftp_port + 1; 834 835 if (daemon->tftp_max > max_fd) 836 { 837 daemon->tftp_max = max_fd; 838 my_syslog(MS_TFTP | LOG_WARNING, 839 _("restricting maximum simultaneous TFTP transfers to %d"), 840 daemon->tftp_max); 841 } 842 } 843#endif 844 845 /* finished start-up - release original process */ 846 if (err_pipe[1] != -1) 847 while (retry_send(close(err_pipe[1]))); 848 849 if (daemon->port != 0) 850 check_servers(); 851 852 pid = getpid(); 853 854#ifdef HAVE_INOTIFY 855 /* Using inotify, have to select a resolv file at startup */ 856 poll_resolv(1, 0, now); 857#endif 858 859 while (1) 860 { 861 int t, timeout = -1; 862 863 poll_reset(); 864 865 /* if we are out of resources, find how long we have to wait 866 for some to come free, we'll loop around then and restart 867 listening for queries */ 868 if ((t = set_dns_listeners(now)) != 0) 869 timeout = t * 1000; 870 871 /* Whilst polling for the dbus, or doing a tftp transfer, wake every quarter second */ 872 if (daemon->tftp_trans || 873 (option_bool(OPT_DBUS) && !daemon->dbus)) 874 timeout = 250; 875 876 /* Wake every second whilst waiting for DAD to complete */ 877 else if (is_dad_listeners()) 878 timeout = 1000; 879 880#ifdef HAVE_DBUS 881 set_dbus_listeners(); 882#endif 883 884#ifdef HAVE_DHCP 885 if (daemon->dhcp || daemon->relay4) 886 { 887 poll_listen(daemon->dhcpfd, POLLIN); 888 if (daemon->pxefd != -1) 889 poll_listen(daemon->pxefd, POLLIN); 890 } 891#endif 892 893#ifdef HAVE_DHCP6 894 if (daemon->doing_dhcp6 || daemon->relay6) 895 poll_listen(daemon->dhcp6fd, POLLIN); 896 897 if (daemon->doing_ra) 898 poll_listen(daemon->icmp6fd, POLLIN); 899#endif 900 901#ifdef HAVE_INOTIFY 902 if (daemon->inotifyfd != -1) 903 poll_listen(daemon->inotifyfd, POLLIN); 904#endif 905 906#if defined(HAVE_LINUX_NETWORK) 907 poll_listen(daemon->netlinkfd, POLLIN); 908#elif defined(HAVE_BSD_NETWORK) 909 poll_listen(daemon->routefd, POLLIN); 910#endif 911 912 poll_listen(piperead, POLLIN); 913 914#ifdef HAVE_DHCP 915# ifdef HAVE_SCRIPT 916 while (helper_buf_empty() && do_script_run(now)); 917 918# ifdef HAVE_TFTP 919 while (helper_buf_empty() && do_tftp_script_run()); 920# endif 921 922 if (!helper_buf_empty()) 923 poll_listen(daemon->helperfd, POLLOUT); 924# else 925 /* need this for other side-effects */ 926 while (do_script_run(now)); 927 928# ifdef HAVE_TFTP 929 while (do_tftp_script_run()); 930# endif 931 932# endif 933#endif 934 935 /* must do this just before select(), when we know no 936 more calls to my_syslog() can occur */ 937 set_log_writer(); 938 939 if (do_poll(timeout) < 0) 940 continue; 941 942 now = dnsmasq_time(); 943 944 check_log_writer(0); 945 946 /* prime. */ 947 enumerate_interfaces(1); 948 949 /* Check the interfaces to see if any have exited DAD state 950 and if so, bind the address. */ 951 if (is_dad_listeners()) 952 { 953 enumerate_interfaces(0); 954 /* NB, is_dad_listeners() == 1 --> we're binding interfaces */ 955 create_bound_listeners(0); 956 warn_bound_listeners(); 957 } 958 959#if defined(HAVE_LINUX_NETWORK) 960 if (poll_check(daemon->netlinkfd, POLLIN)) 961 netlink_multicast(); 962#elif defined(HAVE_BSD_NETWORK) 963 if (poll_check(daemon->routefd, POLLIN)) 964 route_sock(); 965#endif 966 967#ifdef HAVE_INOTIFY 968 if (daemon->inotifyfd != -1 && poll_check(daemon->inotifyfd, POLLIN) && inotify_check(now)) 969 { 970 if (daemon->port != 0 && !option_bool(OPT_NO_POLL)) 971 poll_resolv(1, 1, now); 972 } 973#else 974 /* Check for changes to resolv files once per second max. */ 975 /* Don't go silent for long periods if the clock goes backwards. */ 976 if (daemon->last_resolv == 0 || 977 difftime(now, daemon->last_resolv) > 1.0 || 978 difftime(now, daemon->last_resolv) < -1.0) 979 { 980 /* poll_resolv doesn't need to reload first time through, since 981 that's queued anyway. */ 982 983 poll_resolv(0, daemon->last_resolv != 0, now); 984 daemon->last_resolv = now; 985 } 986#endif 987 988 if (poll_check(piperead, POLLIN)) 989 async_event(piperead, now); 990 991#ifdef HAVE_DBUS 992 /* if we didn't create a DBus connection, retry now. */ 993 if (option_bool(OPT_DBUS) && !daemon->dbus) 994 { 995 char *err; 996 if ((err = dbus_init())) 997 my_syslog(LOG_WARNING, _("DBus error: %s"), err); 998 if (daemon->dbus) 999 my_syslog(LOG_INFO, _("connected to system DBus")); 1000 } 1001 check_dbus_listeners(); 1002#endif 1003 1004 check_dns_listeners(now); 1005 1006#ifdef HAVE_TFTP 1007 check_tftp_listeners(now); 1008#endif 1009 1010#ifdef HAVE_DHCP 1011 if (daemon->dhcp || daemon->relay4) 1012 { 1013 if (poll_check(daemon->dhcpfd, POLLIN)) 1014 dhcp_packet(now, 0); 1015 if (daemon->pxefd != -1 && poll_check(daemon->pxefd, POLLIN)) 1016 dhcp_packet(now, 1); 1017 } 1018 1019#ifdef HAVE_DHCP6 1020 if ((daemon->doing_dhcp6 || daemon->relay6) && poll_check(daemon->dhcp6fd, POLLIN)) 1021 dhcp6_packet(now); 1022 1023 if (daemon->doing_ra && poll_check(daemon->icmp6fd, POLLIN)) 1024 icmp6_packet(now); 1025#endif 1026 1027# ifdef HAVE_SCRIPT 1028 if (daemon->helperfd != -1 && poll_check(daemon->helperfd, POLLOUT)) 1029 helper_write(); 1030# endif 1031#endif 1032 1033 } 1034} 1035 1036static void sig_handler(int sig) 1037{ 1038 if (pid == 0) 1039 { 1040 /* ignore anything other than TERM during startup 1041 and in helper proc. (helper ignore TERM too) */ 1042 if (sig == SIGTERM) 1043 exit(EC_MISC); 1044 } 1045 else if (pid != getpid()) 1046 { 1047 /* alarm is used to kill TCP children after a fixed time. */ 1048 if (sig == SIGALRM) 1049 _exit(0); 1050 } 1051 else 1052 { 1053 /* master process */ 1054 int event, errsave = errno; 1055 1056 if (sig == SIGHUP) 1057 event = EVENT_RELOAD; 1058 else if (sig == SIGCHLD) 1059 event = EVENT_CHILD; 1060 else if (sig == SIGALRM) 1061 event = EVENT_ALARM; 1062 else if (sig == SIGTERM) 1063 event = EVENT_TERM; 1064 else if (sig == SIGUSR1) 1065 event = EVENT_DUMP; 1066 else if (sig == SIGUSR2) 1067 event = EVENT_REOPEN; 1068 else 1069 return; 1070 1071 send_event(pipewrite, event, 0, NULL); 1072 errno = errsave; 1073 } 1074} 1075 1076/* now == 0 -> queue immediate callback */ 1077void send_alarm(time_t event, time_t now) 1078{ 1079 if (now == 0 || event != 0) 1080 { 1081 /* alarm(0) or alarm(-ve) doesn't do what we want.... */ 1082 if ((now == 0 || difftime(event, now) <= 0.0)) 1083 send_event(pipewrite, EVENT_ALARM, 0, NULL); 1084 else 1085 alarm((unsigned)difftime(event, now)); 1086 } 1087} 1088 1089void queue_event(int event) 1090{ 1091 send_event(pipewrite, event, 0, NULL); 1092} 1093 1094void send_event(int fd, int event, int data, char *msg) 1095{ 1096 struct event_desc ev; 1097 struct iovec iov[2]; 1098 1099 ev.event = event; 1100 ev.data = data; 1101 ev.msg_sz = msg ? strlen(msg) : 0; 1102 1103 iov[0].iov_base = &ev; 1104 iov[0].iov_len = sizeof(ev); 1105 iov[1].iov_base = msg; 1106 iov[1].iov_len = ev.msg_sz; 1107 1108 /* error pipe, debug mode. */ 1109 if (fd == -1) 1110 fatal_event(&ev, msg); 1111 else 1112 /* pipe is non-blocking and struct event_desc is smaller than 1113 PIPE_BUF, so this either fails or writes everything */ 1114 while (writev(fd, iov, msg ? 2 : 1) == -1 && errno == EINTR); 1115} 1116 1117/* NOTE: the memory used to return msg is leaked: use msgs in events only 1118 to describe fatal errors. */ 1119static int read_event(int fd, struct event_desc *evp, char **msg) 1120{ 1121 char *buf; 1122 1123 if (!read_write(fd, (unsigned char *)evp, sizeof(struct event_desc), 1)) 1124 return 0; 1125 1126 *msg = NULL; 1127 1128 if (evp->msg_sz != 0 && 1129 (buf = malloc(evp->msg_sz + 1)) && 1130 read_write(fd, (unsigned char *)buf, evp->msg_sz, 1)) 1131 { 1132 buf[evp->msg_sz] = 0; 1133 *msg = buf; 1134 } 1135 1136 return 1; 1137} 1138 1139static void fatal_event(struct event_desc *ev, char *msg) 1140{ 1141 errno = ev->data; 1142 1143 switch (ev->event) 1144 { 1145 case EVENT_DIE: 1146 exit(0); 1147 1148 case EVENT_FORK_ERR: 1149 die(_("cannot fork into background: %s"), NULL, EC_MISC); 1150 1151 case EVENT_PIPE_ERR: 1152 die(_("failed to create helper: %s"), NULL, EC_MISC); 1153 1154 case EVENT_CAP_ERR: 1155 die(_("setting capabilities failed: %s"), NULL, EC_MISC); 1156 1157 case EVENT_USER_ERR: 1158 die(_("failed to change user-id to %s: %s"), msg, EC_MISC); 1159 1160 case EVENT_GROUP_ERR: 1161 die(_("failed to change group-id to %s: %s"), msg, EC_MISC); 1162 1163 case EVENT_PIDFILE: 1164 die(_("failed to open pidfile %s: %s"), msg, EC_FILE); 1165 1166 case EVENT_LOG_ERR: 1167 die(_("cannot open log %s: %s"), msg, EC_FILE); 1168 1169 case EVENT_LUA_ERR: 1170 die(_("failed to load Lua script: %s"), msg, EC_MISC); 1171 1172 case EVENT_TFTP_ERR: 1173 die(_("TFTP directory %s inaccessible: %s"), msg, EC_FILE); 1174 1175 case EVENT_TIME_ERR: 1176 die(_("cannot create timestamp file %s: %s" ), msg, EC_BADCONF); 1177 } 1178} 1179 1180static void async_event(int pipe, time_t now) 1181{ 1182 pid_t p; 1183 struct event_desc ev; 1184 int i, check = 0; 1185 char *msg; 1186 1187 /* NOTE: the memory used to return msg is leaked: use msgs in events only 1188 to describe fatal errors. */ 1189 1190 if (read_event(pipe, &ev, &msg)) 1191 switch (ev.event) 1192 { 1193 case EVENT_RELOAD: 1194#ifdef HAVE_DNSSEC 1195 if (option_bool(OPT_DNSSEC_VALID) && option_bool(OPT_DNSSEC_TIME)) 1196 { 1197 my_syslog(LOG_INFO, _("now checking DNSSEC signature timestamps")); 1198 reset_option_bool(OPT_DNSSEC_TIME); 1199 } 1200#endif 1201 /* fall through */ 1202 1203 case EVENT_INIT: 1204 clear_cache_and_reload(now); 1205 1206 if (daemon->port != 0) 1207 { 1208 if (daemon->resolv_files && option_bool(OPT_NO_POLL)) 1209 { 1210 reload_servers(daemon->resolv_files->name); 1211 check = 1; 1212 } 1213 1214 if (daemon->servers_file) 1215 { 1216 read_servers_file(); 1217 check = 1; 1218 } 1219 1220 if (check) 1221 check_servers(); 1222 } 1223 1224#ifdef HAVE_DHCP 1225 rerun_scripts(); 1226#endif 1227 break; 1228 1229 case EVENT_DUMP: 1230 if (daemon->port != 0) 1231 dump_cache(now); 1232 break; 1233 1234 case EVENT_ALARM: 1235#ifdef HAVE_DHCP 1236 if (daemon->dhcp || daemon->doing_dhcp6) 1237 { 1238 lease_prune(NULL, now); 1239 lease_update_file(now); 1240 } 1241#ifdef HAVE_DHCP6 1242 else if (daemon->doing_ra) 1243 /* Not doing DHCP, so no lease system, manage alarms for ra only */ 1244 send_alarm(periodic_ra(now), now); 1245#endif 1246#endif 1247 break; 1248 1249 case EVENT_CHILD: 1250 /* See Stevens 5.10 */ 1251 while ((p = waitpid(-1, NULL, WNOHANG)) != 0) 1252 if (p == -1) 1253 { 1254 if (errno != EINTR) 1255 break; 1256 } 1257 else 1258 for (i = 0 ; i < MAX_PROCS; i++) 1259 if (daemon->tcp_pids[i] == p) 1260 daemon->tcp_pids[i] = 0; 1261 break; 1262 1263 case EVENT_KILLED: 1264 my_syslog(LOG_WARNING, _("script process killed by signal %d"), ev.data); 1265 break; 1266 1267 case EVENT_EXITED: 1268 my_syslog(LOG_WARNING, _("script process exited with status %d"), ev.data); 1269 break; 1270 1271 case EVENT_EXEC_ERR: 1272 my_syslog(LOG_ERR, _("failed to execute %s: %s"), 1273 daemon->lease_change_command, strerror(ev.data)); 1274 break; 1275 1276 /* necessary for fatal errors in helper */ 1277 case EVENT_USER_ERR: 1278 case EVENT_DIE: 1279 case EVENT_LUA_ERR: 1280 fatal_event(&ev, msg); 1281 break; 1282 1283 case EVENT_REOPEN: 1284 /* Note: this may leave TCP-handling processes with the old file still open. 1285 Since any such process will die in CHILD_LIFETIME or probably much sooner, 1286 we leave them logging to the old file. */ 1287 if (daemon->log_file != NULL) 1288 log_reopen(daemon->log_file); 1289#if defined(HAVE_DHCP) && defined(HAVE_LEASEFILE_EXPIRE) 1290 if (daemon->dhcp || daemon->dhcp6) 1291 lease_flush_file(now); 1292#endif 1293 break; 1294 1295 case EVENT_NEWADDR: 1296 newaddress(now); 1297 break; 1298 1299 case EVENT_NEWROUTE: 1300 resend_query(); 1301 /* Force re-reading resolv file right now, for luck. */ 1302 poll_resolv(0, 1, now); 1303 break; 1304 1305 case EVENT_TERM: 1306 /* Knock all our children on the head. */ 1307 for (i = 0; i < MAX_PROCS; i++) 1308 if (daemon->tcp_pids[i] != 0) 1309 kill(daemon->tcp_pids[i], SIGALRM); 1310 1311#if defined(HAVE_SCRIPT) 1312 /* handle pending lease transitions */ 1313 if (daemon->helperfd != -1) 1314 { 1315 /* block in writes until all done */ 1316 if ((i = fcntl(daemon->helperfd, F_GETFL)) != -1) 1317 fcntl(daemon->helperfd, F_SETFL, i & ~O_NONBLOCK); 1318 do { 1319 helper_write(); 1320 } while (!helper_buf_empty() || do_script_run(now)); 1321 while (retry_send(close(daemon->helperfd))); 1322 } 1323#endif 1324 1325#if defined(HAVE_DHCP) && defined(HAVE_LEASEFILE_EXPIRE) 1326 if (daemon->dhcp || daemon->dhcp6) 1327 lease_flush_file(now); 1328#endif 1329 if (daemon->lease_stream) 1330 fclose(daemon->lease_stream); 1331 1332#ifdef HAVE_DNSSEC 1333 /* update timestamp file on TERM if time is considered valid */ 1334 if (daemon->back_to_the_future) 1335 { 1336 if (utime(daemon->timestamp_file, NULL) == -1) 1337 my_syslog(LOG_ERR, _("failed to update mtime on %s: %s"), daemon->timestamp_file, strerror(errno)); 1338 } 1339#endif 1340 1341 if (daemon->runfile) 1342 unlink(daemon->runfile); 1343 1344 my_syslog(LOG_INFO, _("exiting on receipt of SIGTERM")); 1345 flush_log(); 1346 exit(EC_GOOD); 1347 } 1348} 1349 1350static void poll_resolv(int force, int do_reload, time_t now) 1351{ 1352 struct resolvc *res, *latest; 1353 struct stat statbuf; 1354 time_t last_change = 0; 1355 /* There may be more than one possible file. 1356 Go through and find the one which changed _last_. 1357 Warn of any which can't be read. */ 1358 1359 if (daemon->port == 0 || option_bool(OPT_NO_POLL)) 1360 return; 1361 1362 for (latest = NULL, res = daemon->resolv_files; res; res = res->next) 1363 if (stat(res->name, &statbuf) == -1) 1364 { 1365 if (force) 1366 { 1367 res->mtime = 0; 1368 continue; 1369 } 1370 1371 if (!res->logged) 1372 my_syslog(LOG_WARNING, _("failed to access %s: %s"), res->name, strerror(errno)); 1373 res->logged = 1; 1374 1375 if (res->mtime != 0) 1376 { 1377 /* existing file evaporated, force selection of the latest 1378 file even if its mtime hasn't changed since we last looked */ 1379 poll_resolv(1, do_reload, now); 1380 return; 1381 } 1382 } 1383 else 1384 { 1385 res->logged = 0; 1386 if (force || (statbuf.st_mtime != res->mtime)) 1387 { 1388 res->mtime = statbuf.st_mtime; 1389 if (difftime(statbuf.st_mtime, last_change) > 0.0) 1390 { 1391 last_change = statbuf.st_mtime; 1392 latest = res; 1393 } 1394 } 1395 } 1396 1397 if (latest) 1398 { 1399 static int warned = 0; 1400 if (reload_servers(latest->name)) 1401 { 1402 my_syslog(LOG_INFO, _("reading %s"), latest->name); 1403 warned = 0; 1404 check_servers(); 1405 if (option_bool(OPT_RELOAD) && do_reload) 1406 clear_cache_and_reload(now); 1407 } 1408 else 1409 { 1410 latest->mtime = 0; 1411 if (!warned) 1412 { 1413 my_syslog(LOG_WARNING, _("no servers found in %s, will retry"), latest->name); 1414 warned = 1; 1415 } 1416 } 1417 } 1418} 1419 1420void clear_cache_and_reload(time_t now) 1421{ 1422 (void)now; 1423 1424 if (daemon->port != 0) 1425 cache_reload(); 1426 1427#ifdef HAVE_DHCP 1428 if (daemon->dhcp || daemon->doing_dhcp6) 1429 { 1430 if (option_bool(OPT_ETHERS)) 1431 dhcp_read_ethers(); 1432 reread_dhcp(); 1433#ifdef HAVE_INOTIFY 1434 set_dynamic_inotify(AH_DHCP_HST | AH_DHCP_OPT, 0, NULL, 0); 1435#endif 1436 dhcp_update_configs(daemon->dhcp_conf); 1437 lease_update_from_configs(); 1438 lease_update_file(now); 1439 lease_update_dns(1); 1440 } 1441#ifdef HAVE_DHCP6 1442 else if (daemon->doing_ra) 1443 /* Not doing DHCP, so no lease system, manage 1444 alarms for ra only */ 1445 send_alarm(periodic_ra(now), now); 1446#endif 1447#endif 1448} 1449 1450static int set_dns_listeners(time_t now) 1451{ 1452 struct serverfd *serverfdp; 1453 struct listener *listener; 1454 int wait = 0, i; 1455 1456#ifdef HAVE_TFTP 1457 int tftp = 0; 1458 struct tftp_transfer *transfer; 1459 for (transfer = daemon->tftp_trans; transfer; transfer = transfer->next) 1460 { 1461 tftp++; 1462 poll_listen(transfer->sockfd, POLLIN); 1463 } 1464#endif 1465 1466 /* will we be able to get memory? */ 1467 if (daemon->port != 0) 1468 get_new_frec(now, &wait, 0); 1469 1470 for (serverfdp = daemon->sfds; serverfdp; serverfdp = serverfdp->next) 1471 poll_listen(serverfdp->fd, POLLIN); 1472 1473 if (daemon->port != 0 && !daemon->osport) 1474 for (i = 0; i < RANDOM_SOCKS; i++) 1475 if (daemon->randomsocks[i].refcount != 0) 1476 poll_listen(daemon->randomsocks[i].fd, POLLIN); 1477 1478 for (listener = daemon->listeners; listener; listener = listener->next) 1479 { 1480 /* only listen for queries if we have resources */ 1481 if (listener->fd != -1 && wait == 0) 1482 poll_listen(listener->fd, POLLIN); 1483 1484 /* death of a child goes through the select loop, so 1485 we don't need to explicitly arrange to wake up here */ 1486 if (listener->tcpfd != -1) 1487 for (i = 0; i < MAX_PROCS; i++) 1488 if (daemon->tcp_pids[i] == 0) 1489 { 1490 poll_listen(listener->tcpfd, POLLIN); 1491 break; 1492 } 1493 1494#ifdef HAVE_TFTP 1495 if (tftp <= daemon->tftp_max && listener->tftpfd != -1) 1496 poll_listen(listener->tftpfd, POLLIN); 1497#endif 1498 1499 } 1500 1501 return wait; 1502} 1503 1504static void check_dns_listeners(time_t now) 1505{ 1506 struct serverfd *serverfdp; 1507 struct listener *listener; 1508 int i; 1509 1510 for (serverfdp = daemon->sfds; serverfdp; serverfdp = serverfdp->next) 1511 if (poll_check(serverfdp->fd, POLLIN)) 1512 reply_query(serverfdp->fd, serverfdp->source_addr.sa.sa_family, now); 1513 1514 if (daemon->port != 0 && !daemon->osport) 1515 for (i = 0; i < RANDOM_SOCKS; i++) 1516 if (daemon->randomsocks[i].refcount != 0 && 1517 poll_check(daemon->randomsocks[i].fd, POLLIN)) 1518 reply_query(daemon->randomsocks[i].fd, daemon->randomsocks[i].family, now); 1519 1520 for (listener = daemon->listeners; listener; listener = listener->next) 1521 { 1522 if (listener->fd != -1 && poll_check(listener->fd, POLLIN)) 1523 receive_query(listener, now); 1524 1525#ifdef HAVE_TFTP 1526 if (listener->tftpfd != -1 && poll_check(listener->tftpfd, POLLIN)) 1527 tftp_request(listener, now); 1528#endif 1529 1530 if (listener->tcpfd != -1 && poll_check(listener->tcpfd, POLLIN)) 1531 { 1532 int confd, client_ok = 1; 1533 struct irec *iface = NULL; 1534 pid_t p; 1535 union mysockaddr tcp_addr; 1536 socklen_t tcp_len = sizeof(union mysockaddr); 1537 1538 while ((confd = accept(listener->tcpfd, NULL, NULL)) == -1 && errno == EINTR); 1539 1540 if (confd == -1) 1541 continue; 1542 1543 if (getsockname(confd, (struct sockaddr *)&tcp_addr, &tcp_len) == -1) 1544 { 1545 while (retry_send(close(confd))); 1546 continue; 1547 } 1548 1549 /* Make sure that the interface list is up-to-date. 1550 1551 We do this here as we may need the results below, and 1552 the DNS code needs them for --interface-name stuff. 1553 1554 Multiple calls to enumerate_interfaces() per select loop are 1555 inhibited, so calls to it in the child process (which doesn't select()) 1556 have no effect. This avoids two processes reading from the same 1557 netlink fd and screwing the pooch entirely. 1558 */ 1559 1560 enumerate_interfaces(0); 1561 1562 if (option_bool(OPT_NOWILD)) 1563 iface = listener->iface; /* May be NULL */ 1564 else 1565 { 1566 int if_index; 1567 char intr_name[IF_NAMESIZE]; 1568 1569 /* if we can find the arrival interface, check it's one that's allowed */ 1570 if ((if_index = tcp_interface(confd, tcp_addr.sa.sa_family)) != 0 && 1571 indextoname(listener->tcpfd, if_index, intr_name)) 1572 { 1573 struct all_addr addr; 1574 addr.addr.addr4 = tcp_addr.in.sin_addr; 1575#ifdef HAVE_IPV6 1576 if (tcp_addr.sa.sa_family == AF_INET6) 1577 addr.addr.addr6 = tcp_addr.in6.sin6_addr; 1578#endif 1579 1580 for (iface = daemon->interfaces; iface; iface = iface->next) 1581 if (iface->index == if_index) 1582 break; 1583 1584 if (!iface && !loopback_exception(listener->tcpfd, tcp_addr.sa.sa_family, &addr, intr_name)) 1585 client_ok = 0; 1586 } 1587 1588 if (option_bool(OPT_CLEVERBIND)) 1589 iface = listener->iface; /* May be NULL */ 1590 else 1591 { 1592 /* Check for allowed interfaces when binding the wildcard address: 1593 we do this by looking for an interface with the same address as 1594 the local address of the TCP connection, then looking to see if that's 1595 an allowed interface. As a side effect, we get the netmask of the 1596 interface too, for localisation. */ 1597 1598 for (iface = daemon->interfaces; iface; iface = iface->next) 1599 if (sockaddr_isequal(&iface->addr, &tcp_addr)) 1600 break; 1601 1602 if (!iface) 1603 client_ok = 0; 1604 } 1605 } 1606 1607 if (!client_ok) 1608 { 1609 shutdown(confd, SHUT_RDWR); 1610 while (retry_send(close(confd))); 1611 } 1612#ifndef NO_FORK 1613 else if (!option_bool(OPT_DEBUG) && (p = fork()) != 0) 1614 { 1615 if (p != -1) 1616 { 1617 int i; 1618 for (i = 0; i < MAX_PROCS; i++) 1619 if (daemon->tcp_pids[i] == 0) 1620 { 1621 daemon->tcp_pids[i] = p; 1622 break; 1623 } 1624 } 1625 while (retry_send(close(confd))); 1626 1627 /* The child can use up to TCP_MAX_QUERIES ids, so skip that many. */ 1628 daemon->log_id += TCP_MAX_QUERIES; 1629 } 1630#endif 1631 else 1632 { 1633 unsigned char *buff; 1634 struct server *s; 1635 int flags; 1636 struct in_addr netmask; 1637 int auth_dns; 1638 1639 if (iface) 1640 { 1641 netmask = iface->netmask; 1642 auth_dns = iface->dns_auth; 1643 } 1644 else 1645 { 1646 netmask.s_addr = 0; 1647 auth_dns = 0; 1648 } 1649 1650#ifndef NO_FORK 1651 /* Arrange for SIGALARM after CHILD_LIFETIME seconds to 1652 terminate the process. */ 1653 if (!option_bool(OPT_DEBUG)) 1654 alarm(CHILD_LIFETIME); 1655#endif 1656 1657 /* start with no upstream connections. */ 1658 for (s = daemon->servers; s; s = s->next) 1659 s->tcpfd = -1; 1660 1661 /* The connected socket inherits non-blocking 1662 attribute from the listening socket. 1663 Reset that here. */ 1664 if ((flags = fcntl(confd, F_GETFL, 0)) != -1) 1665 fcntl(confd, F_SETFL, flags & ~O_NONBLOCK); 1666 1667 buff = tcp_request(confd, now, &tcp_addr, netmask, auth_dns); 1668 1669 shutdown(confd, SHUT_RDWR); 1670 while (retry_send(close(confd))); 1671 1672 if (buff) 1673 free(buff); 1674 1675 for (s = daemon->servers; s; s = s->next) 1676 if (s->tcpfd != -1) 1677 { 1678 shutdown(s->tcpfd, SHUT_RDWR); 1679 while (retry_send(close(s->tcpfd))); 1680 } 1681#ifndef NO_FORK 1682 if (!option_bool(OPT_DEBUG)) 1683 { 1684 flush_log(); 1685 _exit(0); 1686 } 1687#endif 1688 } 1689 } 1690 } 1691} 1692 1693#ifdef HAVE_DHCP 1694int make_icmp_sock(void) 1695{ 1696 int fd; 1697 int zeroopt = 0; 1698 1699 if ((fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP)) != -1) 1700 { 1701 if (!fix_fd(fd) || 1702 setsockopt(fd, SOL_SOCKET, SO_DONTROUTE, &zeroopt, sizeof(zeroopt)) == -1) 1703 { 1704 close(fd); 1705 fd = -1; 1706 } 1707 } 1708 1709 return fd; 1710} 1711 1712int icmp_ping(struct in_addr addr) 1713{ 1714 /* Try and get an ICMP echo from a machine. */ 1715 1716 /* Note that whilst in the three second wait, we check for 1717 (and service) events on the DNS and TFTP sockets, (so doing that 1718 better not use any resources our caller has in use...) 1719 but we remain deaf to signals or further DHCP packets. */ 1720 1721 /* There can be a problem using dnsmasq_time() to end the loop, since 1722 it's not monotonic, and can go backwards if the system clock is 1723 tweaked, leading to the code getting stuck in this loop and 1724 ignoring DHCP requests. To fix this, we check to see if select returned 1725 as a result of a timeout rather than a socket becoming available. We 1726 only allow this to happen as many times as it takes to get to the wait time 1727 in quarter-second chunks. This provides a fallback way to end loop. */ 1728 1729 int fd, rc; 1730 struct sockaddr_in saddr; 1731 struct { 1732 struct ip ip; 1733 struct icmp icmp; 1734 } packet; 1735 unsigned short id = rand16(); 1736 unsigned int i, j, timeout_count; 1737 int gotreply = 0; 1738 time_t start, now; 1739 1740#if defined(HAVE_LINUX_NETWORK) || defined (HAVE_SOLARIS_NETWORK) 1741 if ((fd = make_icmp_sock()) == -1) 1742 return 0; 1743#else 1744 int opt = 2000; 1745 fd = daemon->dhcp_icmp_fd; 1746 setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)); 1747#endif 1748 1749 saddr.sin_family = AF_INET; 1750 saddr.sin_port = 0; 1751 saddr.sin_addr = addr; 1752#ifdef HAVE_SOCKADDR_SA_LEN 1753 saddr.sin_len = sizeof(struct sockaddr_in); 1754#endif 1755 1756 memset(&packet.icmp, 0, sizeof(packet.icmp)); 1757 packet.icmp.icmp_type = ICMP_ECHO; 1758 packet.icmp.icmp_id = id; 1759 for (j = 0, i = 0; i < sizeof(struct icmp) / 2; i++) 1760 j += ((u16 *)&packet.icmp)[i]; 1761 while (j>>16) 1762 j = (j & 0xffff) + (j >> 16); 1763 packet.icmp.icmp_cksum = (j == 0xffff) ? j : ~j; 1764 1765 while (retry_send(sendto(fd, (char *)&packet.icmp, sizeof(struct icmp), 0, 1766 (struct sockaddr *)&saddr, sizeof(saddr)))); 1767 1768 for (now = start = dnsmasq_time(), timeout_count = 0; 1769 (difftime(now, start) < (float)PING_WAIT) && (timeout_count < PING_WAIT * 4);) 1770 { 1771 struct sockaddr_in faddr; 1772 socklen_t len = sizeof(faddr); 1773 1774 poll_reset(); 1775 poll_listen(fd, POLLIN); 1776 set_dns_listeners(now); 1777 set_log_writer(); 1778 1779#ifdef HAVE_DHCP6 1780 if (daemon->doing_ra) 1781 poll_listen(daemon->icmp6fd, POLLIN); 1782#endif 1783 1784 rc = do_poll(250); 1785 1786 if (rc < 0) 1787 continue; 1788 else if (rc == 0) 1789 timeout_count++; 1790 1791 now = dnsmasq_time(); 1792 1793 check_log_writer(0); 1794 check_dns_listeners(now); 1795 1796#ifdef HAVE_DHCP6 1797 if (daemon->doing_ra && poll_check(daemon->icmp6fd, POLLIN)) 1798 icmp6_packet(now); 1799#endif 1800 1801#ifdef HAVE_TFTP 1802 check_tftp_listeners(now); 1803#endif 1804 1805 if (poll_check(fd, POLLIN) && 1806 recvfrom(fd, &packet, sizeof(packet), 0, 1807 (struct sockaddr *)&faddr, &len) == sizeof(packet) && 1808 saddr.sin_addr.s_addr == faddr.sin_addr.s_addr && 1809 packet.icmp.icmp_type == ICMP_ECHOREPLY && 1810 packet.icmp.icmp_seq == 0 && 1811 packet.icmp.icmp_id == id) 1812 { 1813 gotreply = 1; 1814 break; 1815 } 1816 } 1817 1818#if defined(HAVE_LINUX_NETWORK) || defined(HAVE_SOLARIS_NETWORK) 1819 while (retry_send(close(fd))); 1820#else 1821 opt = 1; 1822 setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)); 1823#endif 1824 1825 return gotreply; 1826} 1827#endif 1828 1829 1830