1 /* $OpenBSD: dhclient.c,v 1.63 2005/02/06 17:10:13 krw Exp $ */ 2 3 /*- 4 * SPDX-License-Identifier: BSD-3-Clause 5 * 6 * Copyright 2004 Henning Brauer <henning@openbsd.org> 7 * Copyright (c) 1995, 1996, 1997, 1998, 1999 8 * The Internet Software Consortium. All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. Neither the name of The Internet Software Consortium nor the names 20 * of its contributors may be used to endorse or promote products derived 21 * from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND 24 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 25 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 27 * DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR 28 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 31 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 32 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 33 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 34 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 * SUCH DAMAGE. 36 * 37 * This software has been written for the Internet Software Consortium 38 * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie 39 * Enterprises. To learn more about the Internet Software Consortium, 40 * see ``http://www.vix.com/isc''. To learn more about Vixie 41 * Enterprises, see ``http://www.vix.com''. 42 * 43 * This client was substantially modified and enhanced by Elliot Poger 44 * for use on Linux while he was working on the MosquitoNet project at 45 * Stanford. 46 * 47 * The current version owes much to Elliot's Linux enhancements, but 48 * was substantially reorganized and partially rewritten by Ted Lemon 49 * so as to use the same networking framework that the Internet Software 50 * Consortium DHCP server uses. Much system-specific configuration code 51 * was moved into a shell script so that as support for more operating 52 * systems is added, it will not be necessary to port and maintain 53 * system-specific configuration code to these operating systems - instead, 54 * the shell script can invoke the native tools to accomplish the same 55 * purpose. 56 */ 57 58 #include <sys/cdefs.h> 59 __FBSDID("$FreeBSD$"); 60 61 #include "dhcpd.h" 62 #include "privsep.h" 63 64 #include <sys/capsicum.h> 65 #include <sys/endian.h> 66 67 #include <capsicum_helpers.h> 68 #include <libgen.h> 69 70 #include <net80211/ieee80211_freebsd.h> 71 72 73 #ifndef _PATH_VAREMPTY 74 #define _PATH_VAREMPTY "/var/empty" 75 #endif 76 77 #define PERIOD 0x2e 78 #define hyphenchar(c) ((c) == 0x2d) 79 #define bslashchar(c) ((c) == 0x5c) 80 #define periodchar(c) ((c) == PERIOD) 81 #define asterchar(c) ((c) == 0x2a) 82 #define alphachar(c) (((c) >= 0x41 && (c) <= 0x5a) || \ 83 ((c) >= 0x61 && (c) <= 0x7a)) 84 #define digitchar(c) ((c) >= 0x30 && (c) <= 0x39) 85 #define whitechar(c) ((c) == ' ' || (c) == '\t') 86 87 #define borderchar(c) (alphachar(c) || digitchar(c)) 88 #define middlechar(c) (borderchar(c) || hyphenchar(c)) 89 #define domainchar(c) ((c) > 0x20 && (c) < 0x7f) 90 91 #define CLIENT_PATH "PATH=/usr/bin:/usr/sbin:/bin:/sbin" 92 93 cap_channel_t *capsyslog; 94 95 time_t cur_time; 96 static time_t default_lease_time = 43200; /* 12 hours... */ 97 98 const char *path_dhclient_conf = _PATH_DHCLIENT_CONF; 99 char *path_dhclient_db = NULL; 100 101 int log_perror = 1; 102 static int privfd; 103 static int nullfd = -1; 104 105 static char hostname[_POSIX_HOST_NAME_MAX + 1]; 106 107 static struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } }; 108 static struct in_addr inaddr_any, inaddr_broadcast; 109 110 static char *path_dhclient_pidfile; 111 struct pidfh *pidfile; 112 113 /* 114 * ASSERT_STATE() does nothing now; it used to be 115 * assert (state_is == state_shouldbe). 116 */ 117 #define ASSERT_STATE(state_is, state_shouldbe) {} 118 119 /* 120 * We need to check that the expiry, renewal and rebind times are not beyond 121 * the end of time (~2038 when a 32-bit time_t is being used). 122 */ 123 #define TIME_MAX ((((time_t) 1 << (sizeof(time_t) * CHAR_BIT - 2)) - 1) * 2 + 1) 124 125 int log_priority; 126 static int no_daemon; 127 static int unknown_ok = 1; 128 static int routefd; 129 130 struct interface_info *ifi; 131 132 int findproto(char *, int); 133 struct sockaddr *get_ifa(char *, int); 134 void routehandler(struct protocol *); 135 void usage(void); 136 int check_option(struct client_lease *l, int option); 137 int check_classless_option(unsigned char *data, int len); 138 int ipv4addrs(const char * buf); 139 int res_hnok(const char *dn); 140 int check_search(const char *srch); 141 const char *option_as_string(unsigned int code, unsigned char *data, int len); 142 int fork_privchld(int, int); 143 144 #define ROUNDUP(a) \ 145 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) 146 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len)) 147 148 /* Minimum MTU is 68 as per RFC791, p. 24 */ 149 #define MIN_MTU 68 150 151 static time_t scripttime; 152 153 int 154 findproto(char *cp, int n) 155 { 156 struct sockaddr *sa; 157 unsigned i; 158 159 if (n == 0) 160 return -1; 161 for (i = 1; i; i <<= 1) { 162 if (i & n) { 163 sa = (struct sockaddr *)cp; 164 switch (i) { 165 case RTA_IFA: 166 case RTA_DST: 167 case RTA_GATEWAY: 168 case RTA_NETMASK: 169 if (sa->sa_family == AF_INET) 170 return AF_INET; 171 if (sa->sa_family == AF_INET6) 172 return AF_INET6; 173 break; 174 case RTA_IFP: 175 break; 176 } 177 ADVANCE(cp, sa); 178 } 179 } 180 return (-1); 181 } 182 183 struct sockaddr * 184 get_ifa(char *cp, int n) 185 { 186 struct sockaddr *sa; 187 unsigned i; 188 189 if (n == 0) 190 return (NULL); 191 for (i = 1; i; i <<= 1) 192 if (i & n) { 193 sa = (struct sockaddr *)cp; 194 if (i == RTA_IFA) 195 return (sa); 196 ADVANCE(cp, sa); 197 } 198 199 return (NULL); 200 } 201 202 static struct iaddr defaddr = { .len = 4 }; 203 static uint8_t curbssid[6]; 204 205 static void 206 disassoc(void *arg) 207 { 208 struct interface_info *_ifi = arg; 209 210 /* 211 * Clear existing state. 212 */ 213 if (_ifi->client->active != NULL) { 214 script_init("EXPIRE", NULL); 215 script_write_params("old_", 216 _ifi->client->active); 217 if (_ifi->client->alias) 218 script_write_params("alias_", 219 _ifi->client->alias); 220 script_go(); 221 } 222 _ifi->client->state = S_INIT; 223 } 224 225 void 226 routehandler(struct protocol *p __unused) 227 { 228 char msg[2048], *addr; 229 struct rt_msghdr *rtm; 230 struct if_msghdr *ifm; 231 struct ifa_msghdr *ifam; 232 struct if_announcemsghdr *ifan; 233 struct ieee80211_join_event *jev; 234 struct client_lease *l; 235 time_t t = time(NULL); 236 struct sockaddr_in *sa; 237 struct iaddr a; 238 ssize_t n; 239 int linkstat; 240 241 n = read(routefd, &msg, sizeof(msg)); 242 rtm = (struct rt_msghdr *)msg; 243 if (n < (ssize_t)sizeof(rtm->rtm_msglen) || 244 n < (ssize_t)rtm->rtm_msglen || 245 rtm->rtm_version != RTM_VERSION) 246 return; 247 248 switch (rtm->rtm_type) { 249 case RTM_NEWADDR: 250 case RTM_DELADDR: 251 ifam = (struct ifa_msghdr *)rtm; 252 253 if (ifam->ifam_index != ifi->index) 254 break; 255 if (findproto((char *)(ifam + 1), ifam->ifam_addrs) != AF_INET) 256 break; 257 if (scripttime == 0 || t < scripttime + 10) 258 break; 259 260 sa = (struct sockaddr_in*)get_ifa((char *)(ifam + 1), ifam->ifam_addrs); 261 if (sa == NULL) 262 break; 263 264 if ((a.len = sizeof(struct in_addr)) > sizeof(a.iabuf)) 265 error("king bula sez: len mismatch"); 266 memcpy(a.iabuf, &sa->sin_addr, a.len); 267 if (addr_eq(a, defaddr)) 268 break; 269 270 for (l = ifi->client->active; l != NULL; l = l->next) 271 if (addr_eq(a, l->address)) 272 break; 273 274 if (l == NULL) /* added/deleted addr is not the one we set */ 275 break; 276 277 addr = inet_ntoa(sa->sin_addr); 278 if (rtm->rtm_type == RTM_NEWADDR) { 279 /* 280 * XXX: If someone other than us adds our address, 281 * should we assume they are taking over from us, 282 * delete the lease record, and exit without modifying 283 * the interface? 284 */ 285 warning("My address (%s) was re-added", addr); 286 } else { 287 warning("My address (%s) was deleted, dhclient exiting", 288 addr); 289 goto die; 290 } 291 break; 292 case RTM_IFINFO: 293 ifm = (struct if_msghdr *)rtm; 294 if (ifm->ifm_index != ifi->index) 295 break; 296 if ((rtm->rtm_flags & RTF_UP) == 0) { 297 warning("Interface %s is down, dhclient exiting", 298 ifi->name); 299 goto die; 300 } 301 linkstat = interface_link_status(ifi->name); 302 if (linkstat != ifi->linkstat) { 303 debug("%s link state %s -> %s", ifi->name, 304 ifi->linkstat ? "up" : "down", 305 linkstat ? "up" : "down"); 306 ifi->linkstat = linkstat; 307 if (linkstat) 308 state_reboot(ifi); 309 } 310 break; 311 case RTM_IFANNOUNCE: 312 ifan = (struct if_announcemsghdr *)rtm; 313 if (ifan->ifan_what == IFAN_DEPARTURE && 314 ifan->ifan_index == ifi->index) { 315 warning("Interface %s is gone, dhclient exiting", 316 ifi->name); 317 goto die; 318 } 319 break; 320 case RTM_IEEE80211: 321 ifan = (struct if_announcemsghdr *)rtm; 322 if (ifan->ifan_index != ifi->index) 323 break; 324 switch (ifan->ifan_what) { 325 case RTM_IEEE80211_ASSOC: 326 case RTM_IEEE80211_REASSOC: 327 /* 328 * Use assoc/reassoc event to kick state machine 329 * in case we roam. Otherwise fall back to the 330 * normal state machine just like a wired network. 331 */ 332 jev = (struct ieee80211_join_event *) &ifan[1]; 333 if (memcmp(curbssid, jev->iev_addr, 6)) { 334 disassoc(ifi); 335 state_reboot(ifi); 336 } 337 memcpy(curbssid, jev->iev_addr, 6); 338 break; 339 } 340 break; 341 default: 342 break; 343 } 344 return; 345 346 die: 347 script_init("FAIL", NULL); 348 if (ifi->client->alias) 349 script_write_params("alias_", ifi->client->alias); 350 script_go(); 351 if (pidfile != NULL) 352 pidfile_remove(pidfile); 353 exit(1); 354 } 355 356 static void 357 init_casper(void) 358 { 359 cap_channel_t *casper; 360 361 casper = cap_init(); 362 if (casper == NULL) 363 error("unable to start casper"); 364 365 capsyslog = cap_service_open(casper, "system.syslog"); 366 cap_close(casper); 367 if (capsyslog == NULL) 368 error("unable to open system.syslog service"); 369 } 370 371 int 372 main(int argc, char *argv[]) 373 { 374 u_int capmode; 375 int ch, fd, quiet = 0, i = 0; 376 int pipe_fd[2]; 377 int immediate_daemon = 0; 378 struct passwd *pw; 379 pid_t otherpid; 380 cap_rights_t rights; 381 382 init_casper(); 383 384 /* Initially, log errors to stderr as well as to syslogd. */ 385 cap_openlog(capsyslog, getprogname(), LOG_PID | LOG_NDELAY, DHCPD_LOG_FACILITY); 386 cap_setlogmask(capsyslog, LOG_UPTO(LOG_DEBUG)); 387 388 while ((ch = getopt(argc, argv, "bc:dl:p:qu")) != -1) 389 switch (ch) { 390 case 'b': 391 immediate_daemon = 1; 392 break; 393 case 'c': 394 path_dhclient_conf = optarg; 395 break; 396 case 'd': 397 no_daemon = 1; 398 break; 399 case 'l': 400 path_dhclient_db = optarg; 401 break; 402 case 'p': 403 path_dhclient_pidfile = optarg; 404 break; 405 case 'q': 406 quiet = 1; 407 break; 408 case 'u': 409 unknown_ok = 0; 410 break; 411 default: 412 usage(); 413 } 414 415 argc -= optind; 416 argv += optind; 417 418 if (argc != 1) 419 usage(); 420 421 if (path_dhclient_pidfile == NULL) { 422 asprintf(&path_dhclient_pidfile, 423 "%s/dhclient/dhclient.%s.pid", _PATH_VARRUN, *argv); 424 if (path_dhclient_pidfile == NULL) 425 error("asprintf"); 426 } 427 pidfile = pidfile_open(path_dhclient_pidfile, 0644, &otherpid); 428 if (pidfile == NULL) { 429 if (errno == EEXIST) 430 error("dhclient already running, pid: %d.", otherpid); 431 if (errno == EAGAIN) 432 error("dhclient already running."); 433 warning("Cannot open or create pidfile: %m"); 434 } 435 436 if ((ifi = calloc(1, sizeof(struct interface_info))) == NULL) 437 error("calloc"); 438 if (strlcpy(ifi->name, argv[0], IFNAMSIZ) >= IFNAMSIZ) 439 error("Interface name too long"); 440 if (path_dhclient_db == NULL && asprintf(&path_dhclient_db, "%s.%s", 441 _PATH_DHCLIENT_DB, ifi->name) == -1) 442 error("asprintf"); 443 444 if (quiet) 445 log_perror = 0; 446 447 tzset(); 448 time(&cur_time); 449 450 inaddr_broadcast.s_addr = INADDR_BROADCAST; 451 inaddr_any.s_addr = INADDR_ANY; 452 453 read_client_conf(); 454 455 /* The next bit is potentially very time-consuming, so write out 456 the pidfile right away. We will write it out again with the 457 correct pid after daemonizing. */ 458 if (pidfile != NULL) 459 pidfile_write(pidfile); 460 461 if (!interface_link_status(ifi->name)) { 462 fprintf(stderr, "%s: no link ...", ifi->name); 463 fflush(stderr); 464 sleep(1); 465 while (!interface_link_status(ifi->name)) { 466 fprintf(stderr, "."); 467 fflush(stderr); 468 if (++i > 10) { 469 fprintf(stderr, " giving up\n"); 470 exit(1); 471 } 472 sleep(1); 473 } 474 fprintf(stderr, " got link\n"); 475 } 476 ifi->linkstat = 1; 477 478 if ((nullfd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1) 479 error("cannot open %s: %m", _PATH_DEVNULL); 480 481 if ((pw = getpwnam("_dhcp")) == NULL) { 482 warning("no such user: _dhcp, falling back to \"nobody\""); 483 if ((pw = getpwnam("nobody")) == NULL) 484 error("no such user: nobody"); 485 } 486 487 /* 488 * Obtain hostname before entering capability mode - it won't be 489 * possible then, as reading kern.hostname is not permitted. 490 */ 491 if (gethostname(hostname, sizeof(hostname)) < 0) 492 hostname[0] = '\0'; 493 494 priv_script_init("PREINIT", NULL); 495 if (ifi->client->alias) 496 priv_script_write_params("alias_", ifi->client->alias); 497 priv_script_go(); 498 499 /* set up the interface */ 500 discover_interfaces(ifi); 501 502 if (pipe(pipe_fd) == -1) 503 error("pipe"); 504 505 fork_privchld(pipe_fd[0], pipe_fd[1]); 506 507 close(ifi->ufdesc); 508 ifi->ufdesc = -1; 509 close(ifi->wfdesc); 510 ifi->wfdesc = -1; 511 512 close(pipe_fd[0]); 513 privfd = pipe_fd[1]; 514 cap_rights_init(&rights, CAP_READ, CAP_WRITE); 515 if (caph_rights_limit(privfd, &rights) < 0) 516 error("can't limit private descriptor: %m"); 517 518 if ((fd = open(path_dhclient_db, O_RDONLY|O_EXLOCK|O_CREAT, 0)) == -1) 519 error("can't open and lock %s: %m", path_dhclient_db); 520 read_client_leases(); 521 rewrite_client_leases(); 522 close(fd); 523 524 if ((routefd = socket(PF_ROUTE, SOCK_RAW, 0)) != -1) 525 add_protocol("AF_ROUTE", routefd, routehandler, ifi); 526 if (shutdown(routefd, SHUT_WR) < 0) 527 error("can't shutdown route socket: %m"); 528 cap_rights_init(&rights, CAP_EVENT, CAP_READ); 529 if (caph_rights_limit(routefd, &rights) < 0) 530 error("can't limit route socket: %m"); 531 532 endpwent(); 533 534 setproctitle("%s", ifi->name); 535 536 /* setgroups(2) is not permitted in capability mode. */ 537 if (setgroups(1, &pw->pw_gid) != 0) 538 error("can't restrict groups: %m"); 539 540 if (caph_enter_casper() < 0) 541 error("can't enter capability mode: %m"); 542 543 /* 544 * If we are not in capability mode (i.e., Capsicum or libcasper is 545 * disabled), try to restrict filesystem access. This will fail if 546 * kern.chroot_allow_open_directories is 0 or the process is jailed. 547 */ 548 if (cap_getmode(&capmode) < 0 || capmode == 0) { 549 if (chroot(_PATH_VAREMPTY) == -1) 550 error("chroot"); 551 if (chdir("/") == -1) 552 error("chdir(\"/\")"); 553 } 554 555 if (setegid(pw->pw_gid) || setgid(pw->pw_gid) || 556 seteuid(pw->pw_uid) || setuid(pw->pw_uid)) 557 error("can't drop privileges: %m"); 558 559 if (immediate_daemon) 560 go_daemon(); 561 562 ifi->client->state = S_INIT; 563 state_reboot(ifi); 564 565 bootp_packet_handler = do_packet; 566 567 dispatch(); 568 569 /* not reached */ 570 return (0); 571 } 572 573 void 574 usage(void) 575 { 576 577 fprintf(stderr, "usage: %s [-bdqu] ", getprogname()); 578 fprintf(stderr, "[-c conffile] [-l leasefile] interface\n"); 579 exit(1); 580 } 581 582 /* 583 * Individual States: 584 * 585 * Each routine is called from the dhclient_state_machine() in one of 586 * these conditions: 587 * -> entering INIT state 588 * -> recvpacket_flag == 0: timeout in this state 589 * -> otherwise: received a packet in this state 590 * 591 * Return conditions as handled by dhclient_state_machine(): 592 * Returns 1, sendpacket_flag = 1: send packet, reset timer. 593 * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone). 594 * Returns 0: finish the nap which was interrupted for no good reason. 595 * 596 * Several per-interface variables are used to keep track of the process: 597 * active_lease: the lease that is being used on the interface 598 * (null pointer if not configured yet). 599 * offered_leases: leases corresponding to DHCPOFFER messages that have 600 * been sent to us by DHCP servers. 601 * acked_leases: leases corresponding to DHCPACK messages that have been 602 * sent to us by DHCP servers. 603 * sendpacket: DHCP packet we're trying to send. 604 * destination: IP address to send sendpacket to 605 * In addition, there are several relevant per-lease variables. 606 * T1_expiry, T2_expiry, lease_expiry: lease milestones 607 * In the active lease, these control the process of renewing the lease; 608 * In leases on the acked_leases list, this simply determines when we 609 * can no longer legitimately use the lease. 610 */ 611 612 void 613 state_reboot(void *ipp) 614 { 615 struct interface_info *ip = ipp; 616 617 /* If we don't remember an active lease, go straight to INIT. */ 618 if (!ip->client->active || ip->client->active->is_bootp) { 619 state_init(ip); 620 return; 621 } 622 623 /* We are in the rebooting state. */ 624 ip->client->state = S_REBOOTING; 625 626 /* make_request doesn't initialize xid because it normally comes 627 from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER, 628 so pick an xid now. */ 629 ip->client->xid = arc4random(); 630 631 /* Make a DHCPREQUEST packet, and set appropriate per-interface 632 flags. */ 633 make_request(ip, ip->client->active); 634 ip->client->destination = iaddr_broadcast; 635 ip->client->first_sending = cur_time; 636 ip->client->interval = ip->client->config->initial_interval; 637 638 /* Zap the medium list... */ 639 ip->client->medium = NULL; 640 641 /* Send out the first DHCPREQUEST packet. */ 642 send_request(ip); 643 } 644 645 /* 646 * Called when a lease has completely expired and we've 647 * been unable to renew it. 648 */ 649 void 650 state_init(void *ipp) 651 { 652 struct interface_info *ip = ipp; 653 654 ASSERT_STATE(state, S_INIT); 655 656 /* Make a DHCPDISCOVER packet, and set appropriate per-interface 657 flags. */ 658 make_discover(ip, ip->client->active); 659 ip->client->xid = ip->client->packet.xid; 660 ip->client->destination = iaddr_broadcast; 661 ip->client->state = S_SELECTING; 662 ip->client->first_sending = cur_time; 663 ip->client->interval = ip->client->config->initial_interval; 664 665 /* Add an immediate timeout to cause the first DHCPDISCOVER packet 666 to go out. */ 667 send_discover(ip); 668 } 669 670 /* 671 * state_selecting is called when one or more DHCPOFFER packets 672 * have been received and a configurable period of time has passed. 673 */ 674 void 675 state_selecting(void *ipp) 676 { 677 struct interface_info *ip = ipp; 678 struct client_lease *lp, *next, *picked; 679 680 ASSERT_STATE(state, S_SELECTING); 681 682 /* Cancel state_selecting and send_discover timeouts, since either 683 one could have got us here. */ 684 cancel_timeout(state_selecting, ip); 685 cancel_timeout(send_discover, ip); 686 687 /* We have received one or more DHCPOFFER packets. Currently, 688 the only criterion by which we judge leases is whether or 689 not we get a response when we arp for them. */ 690 picked = NULL; 691 for (lp = ip->client->offered_leases; lp; lp = next) { 692 next = lp->next; 693 694 /* Check to see if we got an ARPREPLY for the address 695 in this particular lease. */ 696 if (!picked) { 697 script_init("ARPCHECK", lp->medium); 698 script_write_params("check_", lp); 699 700 /* If the ARPCHECK code detects another 701 machine using the offered address, it exits 702 nonzero. We need to send a DHCPDECLINE and 703 toss the lease. */ 704 if (script_go()) { 705 make_decline(ip, lp); 706 send_decline(ip); 707 goto freeit; 708 } 709 picked = lp; 710 picked->next = NULL; 711 } else { 712 freeit: 713 free_client_lease(lp); 714 } 715 } 716 ip->client->offered_leases = NULL; 717 718 /* If we just tossed all the leases we were offered, go back 719 to square one. */ 720 if (!picked) { 721 ip->client->state = S_INIT; 722 state_init(ip); 723 return; 724 } 725 726 /* If it was a BOOTREPLY, we can just take the address right now. */ 727 if (!picked->options[DHO_DHCP_MESSAGE_TYPE].len) { 728 ip->client->new = picked; 729 730 /* Make up some lease expiry times 731 XXX these should be configurable. */ 732 ip->client->new->expiry = cur_time + 12000; 733 ip->client->new->renewal += cur_time + 8000; 734 ip->client->new->rebind += cur_time + 10000; 735 736 ip->client->state = S_REQUESTING; 737 738 /* Bind to the address we received. */ 739 bind_lease(ip); 740 return; 741 } 742 743 /* Go to the REQUESTING state. */ 744 ip->client->destination = iaddr_broadcast; 745 ip->client->state = S_REQUESTING; 746 ip->client->first_sending = cur_time; 747 ip->client->interval = ip->client->config->initial_interval; 748 749 /* Make a DHCPREQUEST packet from the lease we picked. */ 750 make_request(ip, picked); 751 ip->client->xid = ip->client->packet.xid; 752 753 /* Toss the lease we picked - we'll get it back in a DHCPACK. */ 754 free_client_lease(picked); 755 756 /* Add an immediate timeout to send the first DHCPREQUEST packet. */ 757 send_request(ip); 758 } 759 760 /* state_requesting is called when we receive a DHCPACK message after 761 having sent out one or more DHCPREQUEST packets. */ 762 763 void 764 dhcpack(struct packet *packet) 765 { 766 struct interface_info *ip = packet->interface; 767 struct client_lease *lease; 768 769 /* If we're not receptive to an offer right now, or if the offer 770 has an unrecognizable transaction id, then just drop it. */ 771 if (packet->interface->client->xid != packet->raw->xid || 772 (packet->interface->hw_address.hlen != packet->raw->hlen) || 773 (memcmp(packet->interface->hw_address.haddr, 774 packet->raw->chaddr, packet->raw->hlen))) 775 return; 776 777 if (ip->client->state != S_REBOOTING && 778 ip->client->state != S_REQUESTING && 779 ip->client->state != S_RENEWING && 780 ip->client->state != S_REBINDING) 781 return; 782 783 note("DHCPACK from %s", piaddr(packet->client_addr)); 784 785 lease = packet_to_lease(packet); 786 if (!lease) { 787 note("packet_to_lease failed."); 788 return; 789 } 790 791 ip->client->new = lease; 792 793 /* Stop resending DHCPREQUEST. */ 794 cancel_timeout(send_request, ip); 795 796 /* Figure out the lease time. */ 797 if (ip->client->config->default_actions[DHO_DHCP_LEASE_TIME] == 798 ACTION_SUPERSEDE) 799 ip->client->new->expiry = getULong( 800 ip->client->config->defaults[DHO_DHCP_LEASE_TIME].data); 801 else if (ip->client->new->options[DHO_DHCP_LEASE_TIME].data) 802 ip->client->new->expiry = getULong( 803 ip->client->new->options[DHO_DHCP_LEASE_TIME].data); 804 else 805 ip->client->new->expiry = default_lease_time; 806 /* A number that looks negative here is really just very large, 807 because the lease expiry offset is unsigned. Also make sure that 808 the addition of cur_time below does not overflow (a 32 bit) time_t. */ 809 if (ip->client->new->expiry < 0 || 810 ip->client->new->expiry > TIME_MAX - cur_time) 811 ip->client->new->expiry = TIME_MAX - cur_time; 812 /* XXX should be fixed by resetting the client state */ 813 if (ip->client->new->expiry < 60) 814 ip->client->new->expiry = 60; 815 816 /* Unless overridden in the config, take the server-provided renewal 817 * time if there is one. Otherwise figure it out according to the spec. 818 * Also make sure the renewal time does not exceed the expiry time. 819 */ 820 if (ip->client->config->default_actions[DHO_DHCP_RENEWAL_TIME] == 821 ACTION_SUPERSEDE) 822 ip->client->new->renewal = getULong( 823 ip->client->config->defaults[DHO_DHCP_RENEWAL_TIME].data); 824 else if (ip->client->new->options[DHO_DHCP_RENEWAL_TIME].len) 825 ip->client->new->renewal = getULong( 826 ip->client->new->options[DHO_DHCP_RENEWAL_TIME].data); 827 else 828 ip->client->new->renewal = ip->client->new->expiry / 2; 829 if (ip->client->new->renewal < 0 || 830 ip->client->new->renewal > ip->client->new->expiry / 2) 831 ip->client->new->renewal = ip->client->new->expiry / 2; 832 833 /* Same deal with the rebind time. */ 834 if (ip->client->config->default_actions[DHO_DHCP_REBINDING_TIME] == 835 ACTION_SUPERSEDE) 836 ip->client->new->rebind = getULong( 837 ip->client->config->defaults[DHO_DHCP_REBINDING_TIME].data); 838 else if (ip->client->new->options[DHO_DHCP_REBINDING_TIME].len) 839 ip->client->new->rebind = getULong( 840 ip->client->new->options[DHO_DHCP_REBINDING_TIME].data); 841 else 842 ip->client->new->rebind = ip->client->new->renewal / 4 * 7; 843 if (ip->client->new->rebind < 0 || 844 ip->client->new->rebind > ip->client->new->renewal / 4 * 7) 845 ip->client->new->rebind = ip->client->new->renewal / 4 * 7; 846 847 /* Convert the time offsets into seconds-since-the-epoch */ 848 ip->client->new->expiry += cur_time; 849 ip->client->new->renewal += cur_time; 850 ip->client->new->rebind += cur_time; 851 852 bind_lease(ip); 853 } 854 855 void 856 bind_lease(struct interface_info *ip) 857 { 858 struct option_data *opt; 859 860 /* Remember the medium. */ 861 ip->client->new->medium = ip->client->medium; 862 863 opt = &ip->client->new->options[DHO_INTERFACE_MTU]; 864 if (opt->len == sizeof(u_int16_t)) { 865 u_int16_t mtu = 0; 866 u_int16_t old_mtu = 0; 867 bool supersede = (ip->client->config->default_actions[DHO_INTERFACE_MTU] == 868 ACTION_SUPERSEDE); 869 870 if (supersede) 871 mtu = getUShort(ip->client->config->defaults[DHO_INTERFACE_MTU].data); 872 else 873 mtu = be16dec(opt->data); 874 875 if (ip->client->active) { 876 opt = &ip->client->active->options[DHO_INTERFACE_MTU]; 877 if (opt->len == sizeof(u_int16_t)) { 878 old_mtu = be16dec(opt->data); 879 } 880 } 881 882 if (mtu < MIN_MTU) { 883 /* Treat 0 like a user intentionally doesn't want to change MTU and, 884 * therefore, warning is not needed */ 885 if (!supersede || mtu != 0) 886 warning("mtu size %u < %d: ignored", (unsigned)mtu, MIN_MTU); 887 } else if (ip->client->state != S_RENEWING || mtu != old_mtu) { 888 interface_set_mtu_unpriv(privfd, mtu); 889 } 890 } 891 892 /* Write out the new lease. */ 893 write_client_lease(ip, ip->client->new, 0); 894 895 /* Run the client script with the new parameters. */ 896 script_init((ip->client->state == S_REQUESTING ? "BOUND" : 897 (ip->client->state == S_RENEWING ? "RENEW" : 898 (ip->client->state == S_REBOOTING ? "REBOOT" : "REBIND"))), 899 ip->client->new->medium); 900 if (ip->client->active && ip->client->state != S_REBOOTING) 901 script_write_params("old_", ip->client->active); 902 script_write_params("new_", ip->client->new); 903 if (ip->client->alias) 904 script_write_params("alias_", ip->client->alias); 905 script_go(); 906 907 /* Replace the old active lease with the new one. */ 908 if (ip->client->active) 909 free_client_lease(ip->client->active); 910 ip->client->active = ip->client->new; 911 ip->client->new = NULL; 912 913 /* Set up a timeout to start the renewal process. */ 914 add_timeout(ip->client->active->renewal, state_bound, ip); 915 916 note("bound to %s -- renewal in %d seconds.", 917 piaddr(ip->client->active->address), 918 (int)(ip->client->active->renewal - cur_time)); 919 ip->client->state = S_BOUND; 920 reinitialize_interfaces(); 921 go_daemon(); 922 } 923 924 /* 925 * state_bound is called when we've successfully bound to a particular 926 * lease, but the renewal time on that lease has expired. We are 927 * expected to unicast a DHCPREQUEST to the server that gave us our 928 * original lease. 929 */ 930 void 931 state_bound(void *ipp) 932 { 933 struct interface_info *ip = ipp; 934 u_int8_t *dp = NULL; 935 int len; 936 937 ASSERT_STATE(state, S_BOUND); 938 939 /* T1 has expired. */ 940 make_request(ip, ip->client->active); 941 ip->client->xid = ip->client->packet.xid; 942 943 if (ip->client->config->default_actions[DHO_DHCP_SERVER_IDENTIFIER] == 944 ACTION_SUPERSEDE) { 945 dp = ip->client->config->defaults[DHO_DHCP_SERVER_IDENTIFIER].data; 946 len = ip->client->config->defaults[DHO_DHCP_SERVER_IDENTIFIER].len; 947 } else { 948 dp = ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].data; 949 len = ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].len; 950 } 951 if (len == 4) { 952 memcpy(ip->client->destination.iabuf, dp, len); 953 ip->client->destination.len = len; 954 } else 955 ip->client->destination = iaddr_broadcast; 956 957 ip->client->first_sending = cur_time; 958 ip->client->interval = ip->client->config->initial_interval; 959 ip->client->state = S_RENEWING; 960 961 /* Send the first packet immediately. */ 962 send_request(ip); 963 } 964 965 void 966 bootp(struct packet *packet) 967 { 968 struct iaddrlist *ap; 969 970 if (packet->raw->op != BOOTREPLY) 971 return; 972 973 /* If there's a reject list, make sure this packet's sender isn't 974 on it. */ 975 for (ap = packet->interface->client->config->reject_list; 976 ap; ap = ap->next) { 977 if (addr_eq(packet->client_addr, ap->addr)) { 978 note("BOOTREPLY from %s rejected.", piaddr(ap->addr)); 979 return; 980 } 981 } 982 dhcpoffer(packet); 983 } 984 985 void 986 dhcp(struct packet *packet) 987 { 988 struct iaddrlist *ap; 989 void (*handler)(struct packet *); 990 const char *type; 991 992 switch (packet->packet_type) { 993 case DHCPOFFER: 994 handler = dhcpoffer; 995 type = "DHCPOFFER"; 996 break; 997 case DHCPNAK: 998 handler = dhcpnak; 999 type = "DHCPNACK"; 1000 break; 1001 case DHCPACK: 1002 handler = dhcpack; 1003 type = "DHCPACK"; 1004 break; 1005 default: 1006 return; 1007 } 1008 1009 /* If there's a reject list, make sure this packet's sender isn't 1010 on it. */ 1011 for (ap = packet->interface->client->config->reject_list; 1012 ap; ap = ap->next) { 1013 if (addr_eq(packet->client_addr, ap->addr)) { 1014 note("%s from %s rejected.", type, piaddr(ap->addr)); 1015 return; 1016 } 1017 } 1018 (*handler)(packet); 1019 } 1020 1021 void 1022 dhcpoffer(struct packet *packet) 1023 { 1024 struct interface_info *ip = packet->interface; 1025 struct client_lease *lease, *lp; 1026 int i; 1027 int arp_timeout_needed, stop_selecting; 1028 const char *name = packet->options[DHO_DHCP_MESSAGE_TYPE].len ? 1029 "DHCPOFFER" : "BOOTREPLY"; 1030 1031 /* If we're not receptive to an offer right now, or if the offer 1032 has an unrecognizable transaction id, then just drop it. */ 1033 if (ip->client->state != S_SELECTING || 1034 packet->interface->client->xid != packet->raw->xid || 1035 (packet->interface->hw_address.hlen != packet->raw->hlen) || 1036 (memcmp(packet->interface->hw_address.haddr, 1037 packet->raw->chaddr, packet->raw->hlen))) 1038 return; 1039 1040 note("%s from %s", name, piaddr(packet->client_addr)); 1041 1042 1043 /* If this lease doesn't supply the minimum required parameters, 1044 blow it off. */ 1045 for (i = 0; ip->client->config->required_options[i]; i++) { 1046 if (!packet->options[ip->client->config-> 1047 required_options[i]].len) { 1048 note("%s isn't satisfactory.", name); 1049 return; 1050 } 1051 } 1052 1053 /* If we've already seen this lease, don't record it again. */ 1054 for (lease = ip->client->offered_leases; 1055 lease; lease = lease->next) { 1056 if (lease->address.len == sizeof(packet->raw->yiaddr) && 1057 !memcmp(lease->address.iabuf, 1058 &packet->raw->yiaddr, lease->address.len)) { 1059 debug("%s already seen.", name); 1060 return; 1061 } 1062 } 1063 1064 lease = packet_to_lease(packet); 1065 if (!lease) { 1066 note("packet_to_lease failed."); 1067 return; 1068 } 1069 1070 /* If this lease was acquired through a BOOTREPLY, record that 1071 fact. */ 1072 if (!packet->options[DHO_DHCP_MESSAGE_TYPE].len) 1073 lease->is_bootp = 1; 1074 1075 /* Record the medium under which this lease was offered. */ 1076 lease->medium = ip->client->medium; 1077 1078 /* Send out an ARP Request for the offered IP address. */ 1079 script_init("ARPSEND", lease->medium); 1080 script_write_params("check_", lease); 1081 /* If the script can't send an ARP request without waiting, 1082 we'll be waiting when we do the ARPCHECK, so don't wait now. */ 1083 if (script_go()) 1084 arp_timeout_needed = 0; 1085 else 1086 arp_timeout_needed = 2; 1087 1088 /* Figure out when we're supposed to stop selecting. */ 1089 stop_selecting = 1090 ip->client->first_sending + ip->client->config->select_interval; 1091 1092 /* If this is the lease we asked for, put it at the head of the 1093 list, and don't mess with the arp request timeout. */ 1094 if (lease->address.len == ip->client->requested_address.len && 1095 !memcmp(lease->address.iabuf, 1096 ip->client->requested_address.iabuf, 1097 ip->client->requested_address.len)) { 1098 lease->next = ip->client->offered_leases; 1099 ip->client->offered_leases = lease; 1100 } else { 1101 /* If we already have an offer, and arping for this 1102 offer would take us past the selection timeout, 1103 then don't extend the timeout - just hope for the 1104 best. */ 1105 if (ip->client->offered_leases && 1106 (cur_time + arp_timeout_needed) > stop_selecting) 1107 arp_timeout_needed = 0; 1108 1109 /* Put the lease at the end of the list. */ 1110 lease->next = NULL; 1111 if (!ip->client->offered_leases) 1112 ip->client->offered_leases = lease; 1113 else { 1114 for (lp = ip->client->offered_leases; lp->next; 1115 lp = lp->next) 1116 ; /* nothing */ 1117 lp->next = lease; 1118 } 1119 } 1120 1121 /* If we're supposed to stop selecting before we've had time 1122 to wait for the ARPREPLY, add some delay to wait for 1123 the ARPREPLY. */ 1124 if (stop_selecting - cur_time < arp_timeout_needed) 1125 stop_selecting = cur_time + arp_timeout_needed; 1126 1127 /* If the selecting interval has expired, go immediately to 1128 state_selecting(). Otherwise, time out into 1129 state_selecting at the select interval. */ 1130 if (stop_selecting <= 0) 1131 state_selecting(ip); 1132 else { 1133 add_timeout(stop_selecting, state_selecting, ip); 1134 cancel_timeout(send_discover, ip); 1135 } 1136 } 1137 1138 /* Allocate a client_lease structure and initialize it from the parameters 1139 in the specified packet. */ 1140 1141 struct client_lease * 1142 packet_to_lease(struct packet *packet) 1143 { 1144 struct client_lease *lease; 1145 int i; 1146 1147 lease = malloc(sizeof(struct client_lease)); 1148 1149 if (!lease) { 1150 warning("dhcpoffer: no memory to record lease."); 1151 return (NULL); 1152 } 1153 1154 memset(lease, 0, sizeof(*lease)); 1155 1156 /* Copy the lease options. */ 1157 for (i = 0; i < 256; i++) { 1158 if (packet->options[i].len) { 1159 lease->options[i].data = 1160 malloc(packet->options[i].len + 1); 1161 if (!lease->options[i].data) { 1162 warning("dhcpoffer: no memory for option %d", i); 1163 free_client_lease(lease); 1164 return (NULL); 1165 } else { 1166 memcpy(lease->options[i].data, 1167 packet->options[i].data, 1168 packet->options[i].len); 1169 lease->options[i].len = 1170 packet->options[i].len; 1171 lease->options[i].data[lease->options[i].len] = 1172 0; 1173 } 1174 if (!check_option(lease,i)) { 1175 /* ignore a bogus lease offer */ 1176 warning("Invalid lease option - ignoring offer"); 1177 free_client_lease(lease); 1178 return (NULL); 1179 } 1180 } 1181 } 1182 1183 lease->address.len = sizeof(packet->raw->yiaddr); 1184 memcpy(lease->address.iabuf, &packet->raw->yiaddr, lease->address.len); 1185 1186 lease->nextserver.len = sizeof(packet->raw->siaddr); 1187 memcpy(lease->nextserver.iabuf, &packet->raw->siaddr, lease->nextserver.len); 1188 1189 /* If the server name was filled out, copy it. 1190 Do not attempt to validate the server name as a host name. 1191 RFC 2131 merely states that sname is NUL-terminated (which do 1192 do not assume) and that it is the server's host name. Since 1193 the ISC client and server allow arbitrary characters, we do 1194 as well. */ 1195 if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len || 1196 !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 2)) && 1197 packet->raw->sname[0]) { 1198 lease->server_name = malloc(DHCP_SNAME_LEN + 1); 1199 if (!lease->server_name) { 1200 warning("dhcpoffer: no memory for server name."); 1201 free_client_lease(lease); 1202 return (NULL); 1203 } 1204 memcpy(lease->server_name, packet->raw->sname, DHCP_SNAME_LEN); 1205 lease->server_name[DHCP_SNAME_LEN]='\0'; 1206 } 1207 1208 /* Ditto for the filename. */ 1209 if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len || 1210 !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 1)) && 1211 packet->raw->file[0]) { 1212 /* Don't count on the NUL terminator. */ 1213 lease->filename = malloc(DHCP_FILE_LEN + 1); 1214 if (!lease->filename) { 1215 warning("dhcpoffer: no memory for filename."); 1216 free_client_lease(lease); 1217 return (NULL); 1218 } 1219 memcpy(lease->filename, packet->raw->file, DHCP_FILE_LEN); 1220 lease->filename[DHCP_FILE_LEN]='\0'; 1221 } 1222 return lease; 1223 } 1224 1225 void 1226 dhcpnak(struct packet *packet) 1227 { 1228 struct interface_info *ip = packet->interface; 1229 1230 /* If we're not receptive to an offer right now, or if the offer 1231 has an unrecognizable transaction id, then just drop it. */ 1232 if (packet->interface->client->xid != packet->raw->xid || 1233 (packet->interface->hw_address.hlen != packet->raw->hlen) || 1234 (memcmp(packet->interface->hw_address.haddr, 1235 packet->raw->chaddr, packet->raw->hlen))) 1236 return; 1237 1238 if (ip->client->state != S_REBOOTING && 1239 ip->client->state != S_REQUESTING && 1240 ip->client->state != S_RENEWING && 1241 ip->client->state != S_REBINDING) 1242 return; 1243 1244 note("DHCPNAK from %s", piaddr(packet->client_addr)); 1245 1246 if (!ip->client->active) { 1247 note("DHCPNAK with no active lease.\n"); 1248 return; 1249 } 1250 1251 free_client_lease(ip->client->active); 1252 ip->client->active = NULL; 1253 1254 /* Stop sending DHCPREQUEST packets... */ 1255 cancel_timeout(send_request, ip); 1256 1257 ip->client->state = S_INIT; 1258 state_init(ip); 1259 } 1260 1261 /* Send out a DHCPDISCOVER packet, and set a timeout to send out another 1262 one after the right interval has expired. If we don't get an offer by 1263 the time we reach the panic interval, call the panic function. */ 1264 1265 void 1266 send_discover(void *ipp) 1267 { 1268 struct interface_info *ip = ipp; 1269 int interval, increase = 1; 1270 1271 /* Figure out how long it's been since we started transmitting. */ 1272 interval = cur_time - ip->client->first_sending; 1273 1274 /* If we're past the panic timeout, call the script and tell it 1275 we haven't found anything for this interface yet. */ 1276 if (interval > ip->client->config->timeout) { 1277 state_panic(ip); 1278 return; 1279 } 1280 1281 /* If we're selecting media, try the whole list before doing 1282 the exponential backoff, but if we've already received an 1283 offer, stop looping, because we obviously have it right. */ 1284 if (!ip->client->offered_leases && 1285 ip->client->config->media) { 1286 int fail = 0; 1287 again: 1288 if (ip->client->medium) { 1289 ip->client->medium = ip->client->medium->next; 1290 increase = 0; 1291 } 1292 if (!ip->client->medium) { 1293 if (fail) 1294 error("No valid media types for %s!", ip->name); 1295 ip->client->medium = ip->client->config->media; 1296 increase = 1; 1297 } 1298 1299 note("Trying medium \"%s\" %d", ip->client->medium->string, 1300 increase); 1301 script_init("MEDIUM", ip->client->medium); 1302 if (script_go()) 1303 goto again; 1304 } 1305 1306 /* 1307 * If we're supposed to increase the interval, do so. If it's 1308 * currently zero (i.e., we haven't sent any packets yet), set 1309 * it to one; otherwise, add to it a random number between zero 1310 * and two times itself. On average, this means that it will 1311 * double with every transmission. 1312 */ 1313 if (increase) { 1314 if (!ip->client->interval) 1315 ip->client->interval = 1316 ip->client->config->initial_interval; 1317 else { 1318 ip->client->interval += (arc4random() >> 2) % 1319 (2 * ip->client->interval); 1320 } 1321 1322 /* Don't backoff past cutoff. */ 1323 if (ip->client->interval > 1324 ip->client->config->backoff_cutoff) 1325 ip->client->interval = 1326 ((ip->client->config->backoff_cutoff / 2) 1327 + ((arc4random() >> 2) % 1328 ip->client->config->backoff_cutoff)); 1329 } else if (!ip->client->interval) 1330 ip->client->interval = 1331 ip->client->config->initial_interval; 1332 1333 /* If the backoff would take us to the panic timeout, just use that 1334 as the interval. */ 1335 if (cur_time + ip->client->interval > 1336 ip->client->first_sending + ip->client->config->timeout) 1337 ip->client->interval = 1338 (ip->client->first_sending + 1339 ip->client->config->timeout) - cur_time + 1; 1340 1341 /* Record the number of seconds since we started sending. */ 1342 if (interval < 65536) 1343 ip->client->packet.secs = htons(interval); 1344 else 1345 ip->client->packet.secs = htons(65535); 1346 ip->client->secs = ip->client->packet.secs; 1347 1348 note("DHCPDISCOVER on %s to %s port %d interval %d", 1349 ip->name, inet_ntoa(inaddr_broadcast), REMOTE_PORT, 1350 (int)ip->client->interval); 1351 1352 /* Send out a packet. */ 1353 send_packet_unpriv(privfd, &ip->client->packet, 1354 ip->client->packet_length, inaddr_any, inaddr_broadcast); 1355 1356 add_timeout(cur_time + ip->client->interval, send_discover, ip); 1357 } 1358 1359 /* 1360 * state_panic gets called if we haven't received any offers in a preset 1361 * amount of time. When this happens, we try to use existing leases 1362 * that haven't yet expired, and failing that, we call the client script 1363 * and hope it can do something. 1364 */ 1365 void 1366 state_panic(void *ipp) 1367 { 1368 struct interface_info *ip = ipp; 1369 struct client_lease *loop = ip->client->active; 1370 struct client_lease *lp; 1371 1372 note("No DHCPOFFERS received."); 1373 1374 /* We may not have an active lease, but we may have some 1375 predefined leases that we can try. */ 1376 if (!ip->client->active && ip->client->leases) 1377 goto activate_next; 1378 1379 /* Run through the list of leases and see if one can be used. */ 1380 while (ip->client->active) { 1381 if (ip->client->active->expiry > cur_time) { 1382 note("Trying recorded lease %s", 1383 piaddr(ip->client->active->address)); 1384 /* Run the client script with the existing 1385 parameters. */ 1386 script_init("TIMEOUT", 1387 ip->client->active->medium); 1388 script_write_params("new_", ip->client->active); 1389 if (ip->client->alias) 1390 script_write_params("alias_", 1391 ip->client->alias); 1392 1393 /* If the old lease is still good and doesn't 1394 yet need renewal, go into BOUND state and 1395 timeout at the renewal time. */ 1396 if (!script_go()) { 1397 if (cur_time < 1398 ip->client->active->renewal) { 1399 ip->client->state = S_BOUND; 1400 note("bound: renewal in %d seconds.", 1401 (int)(ip->client->active->renewal - 1402 cur_time)); 1403 add_timeout( 1404 ip->client->active->renewal, 1405 state_bound, ip); 1406 } else { 1407 ip->client->state = S_BOUND; 1408 note("bound: immediate renewal."); 1409 state_bound(ip); 1410 } 1411 reinitialize_interfaces(); 1412 go_daemon(); 1413 return; 1414 } 1415 } 1416 1417 /* If there are no other leases, give up. */ 1418 if (!ip->client->leases) { 1419 ip->client->leases = ip->client->active; 1420 ip->client->active = NULL; 1421 break; 1422 } 1423 1424 activate_next: 1425 /* Otherwise, put the active lease at the end of the 1426 lease list, and try another lease.. */ 1427 for (lp = ip->client->leases; lp->next; lp = lp->next) 1428 ; 1429 lp->next = ip->client->active; 1430 if (lp->next) 1431 lp->next->next = NULL; 1432 ip->client->active = ip->client->leases; 1433 ip->client->leases = ip->client->leases->next; 1434 1435 /* If we already tried this lease, we've exhausted the 1436 set of leases, so we might as well give up for 1437 now. */ 1438 if (ip->client->active == loop) 1439 break; 1440 else if (!loop) 1441 loop = ip->client->active; 1442 } 1443 1444 /* No leases were available, or what was available didn't work, so 1445 tell the shell script that we failed to allocate an address, 1446 and try again later. */ 1447 note("No working leases in persistent database - sleeping.\n"); 1448 script_init("FAIL", NULL); 1449 if (ip->client->alias) 1450 script_write_params("alias_", ip->client->alias); 1451 script_go(); 1452 ip->client->state = S_INIT; 1453 add_timeout(cur_time + ip->client->config->retry_interval, state_init, 1454 ip); 1455 go_daemon(); 1456 } 1457 1458 void 1459 send_request(void *ipp) 1460 { 1461 struct interface_info *ip = ipp; 1462 struct in_addr from, to; 1463 int interval; 1464 1465 /* Figure out how long it's been since we started transmitting. */ 1466 interval = cur_time - ip->client->first_sending; 1467 1468 /* If we're in the INIT-REBOOT or REQUESTING state and we're 1469 past the reboot timeout, go to INIT and see if we can 1470 DISCOVER an address... */ 1471 /* XXX In the INIT-REBOOT state, if we don't get an ACK, it 1472 means either that we're on a network with no DHCP server, 1473 or that our server is down. In the latter case, assuming 1474 that there is a backup DHCP server, DHCPDISCOVER will get 1475 us a new address, but we could also have successfully 1476 reused our old address. In the former case, we're hosed 1477 anyway. This is not a win-prone situation. */ 1478 if ((ip->client->state == S_REBOOTING || 1479 ip->client->state == S_REQUESTING) && 1480 interval > ip->client->config->reboot_timeout) { 1481 cancel: 1482 ip->client->state = S_INIT; 1483 cancel_timeout(send_request, ip); 1484 state_init(ip); 1485 return; 1486 } 1487 1488 /* If we're in the reboot state, make sure the media is set up 1489 correctly. */ 1490 if (ip->client->state == S_REBOOTING && 1491 !ip->client->medium && 1492 ip->client->active->medium ) { 1493 script_init("MEDIUM", ip->client->active->medium); 1494 1495 /* If the medium we chose won't fly, go to INIT state. */ 1496 if (script_go()) 1497 goto cancel; 1498 1499 /* Record the medium. */ 1500 ip->client->medium = ip->client->active->medium; 1501 } 1502 1503 /* If the lease has expired, relinquish the address and go back 1504 to the INIT state. */ 1505 if (ip->client->state != S_REQUESTING && 1506 cur_time > ip->client->active->expiry) { 1507 /* Run the client script with the new parameters. */ 1508 script_init("EXPIRE", NULL); 1509 script_write_params("old_", ip->client->active); 1510 if (ip->client->alias) 1511 script_write_params("alias_", ip->client->alias); 1512 script_go(); 1513 1514 /* Now do a preinit on the interface so that we can 1515 discover a new address. */ 1516 script_init("PREINIT", NULL); 1517 if (ip->client->alias) 1518 script_write_params("alias_", ip->client->alias); 1519 script_go(); 1520 1521 ip->client->state = S_INIT; 1522 state_init(ip); 1523 return; 1524 } 1525 1526 /* Do the exponential backoff... */ 1527 if (!ip->client->interval) 1528 ip->client->interval = ip->client->config->initial_interval; 1529 else 1530 ip->client->interval += ((arc4random() >> 2) % 1531 (2 * ip->client->interval)); 1532 1533 /* Don't backoff past cutoff. */ 1534 if (ip->client->interval > 1535 ip->client->config->backoff_cutoff) 1536 ip->client->interval = 1537 ((ip->client->config->backoff_cutoff / 2) + 1538 ((arc4random() >> 2) % ip->client->interval)); 1539 1540 /* If the backoff would take us to the expiry time, just set the 1541 timeout to the expiry time. */ 1542 if (ip->client->state != S_REQUESTING && 1543 cur_time + ip->client->interval > 1544 ip->client->active->expiry) 1545 ip->client->interval = 1546 ip->client->active->expiry - cur_time + 1; 1547 1548 /* If the lease T2 time has elapsed, or if we're not yet bound, 1549 broadcast the DHCPREQUEST rather than unicasting. */ 1550 if (ip->client->state == S_REQUESTING || 1551 ip->client->state == S_REBOOTING || 1552 cur_time > ip->client->active->rebind) 1553 to.s_addr = INADDR_BROADCAST; 1554 else 1555 memcpy(&to.s_addr, ip->client->destination.iabuf, 1556 sizeof(to.s_addr)); 1557 1558 if (ip->client->state != S_REQUESTING && 1559 ip->client->state != S_REBOOTING) 1560 memcpy(&from, ip->client->active->address.iabuf, 1561 sizeof(from)); 1562 else 1563 from.s_addr = INADDR_ANY; 1564 1565 /* Record the number of seconds since we started sending. */ 1566 if (ip->client->state == S_REQUESTING) 1567 ip->client->packet.secs = ip->client->secs; 1568 else { 1569 if (interval < 65536) 1570 ip->client->packet.secs = htons(interval); 1571 else 1572 ip->client->packet.secs = htons(65535); 1573 } 1574 1575 note("DHCPREQUEST on %s to %s port %d", ip->name, inet_ntoa(to), 1576 REMOTE_PORT); 1577 1578 /* Send out a packet. */ 1579 send_packet_unpriv(privfd, &ip->client->packet, 1580 ip->client->packet_length, from, to); 1581 1582 add_timeout(cur_time + ip->client->interval, send_request, ip); 1583 } 1584 1585 void 1586 send_decline(void *ipp) 1587 { 1588 struct interface_info *ip = ipp; 1589 1590 note("DHCPDECLINE on %s to %s port %d", ip->name, 1591 inet_ntoa(inaddr_broadcast), REMOTE_PORT); 1592 1593 /* Send out a packet. */ 1594 send_packet_unpriv(privfd, &ip->client->packet, 1595 ip->client->packet_length, inaddr_any, inaddr_broadcast); 1596 } 1597 1598 void 1599 make_discover(struct interface_info *ip, struct client_lease *lease) 1600 { 1601 unsigned char discover = DHCPDISCOVER; 1602 struct tree_cache *options[256]; 1603 struct tree_cache option_elements[256]; 1604 int i; 1605 1606 memset(option_elements, 0, sizeof(option_elements)); 1607 memset(options, 0, sizeof(options)); 1608 memset(&ip->client->packet, 0, sizeof(ip->client->packet)); 1609 1610 /* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */ 1611 i = DHO_DHCP_MESSAGE_TYPE; 1612 options[i] = &option_elements[i]; 1613 options[i]->value = &discover; 1614 options[i]->len = sizeof(discover); 1615 options[i]->buf_size = sizeof(discover); 1616 options[i]->timeout = 0xFFFFFFFF; 1617 1618 /* Request the options we want */ 1619 i = DHO_DHCP_PARAMETER_REQUEST_LIST; 1620 options[i] = &option_elements[i]; 1621 options[i]->value = ip->client->config->requested_options; 1622 options[i]->len = ip->client->config->requested_option_count; 1623 options[i]->buf_size = 1624 ip->client->config->requested_option_count; 1625 options[i]->timeout = 0xFFFFFFFF; 1626 1627 /* If we had an address, try to get it again. */ 1628 if (lease) { 1629 ip->client->requested_address = lease->address; 1630 i = DHO_DHCP_REQUESTED_ADDRESS; 1631 options[i] = &option_elements[i]; 1632 options[i]->value = lease->address.iabuf; 1633 options[i]->len = lease->address.len; 1634 options[i]->buf_size = lease->address.len; 1635 options[i]->timeout = 0xFFFFFFFF; 1636 } else 1637 ip->client->requested_address.len = 0; 1638 1639 /* Send any options requested in the config file. */ 1640 for (i = 0; i < 256; i++) 1641 if (!options[i] && 1642 ip->client->config->send_options[i].data) { 1643 options[i] = &option_elements[i]; 1644 options[i]->value = 1645 ip->client->config->send_options[i].data; 1646 options[i]->len = 1647 ip->client->config->send_options[i].len; 1648 options[i]->buf_size = 1649 ip->client->config->send_options[i].len; 1650 options[i]->timeout = 0xFFFFFFFF; 1651 } 1652 1653 /* send host name if not set via config file. */ 1654 if (!options[DHO_HOST_NAME]) { 1655 if (hostname[0] != '\0') { 1656 size_t len; 1657 char* posDot = strchr(hostname, '.'); 1658 if (posDot != NULL) 1659 len = posDot - hostname; 1660 else 1661 len = strlen(hostname); 1662 options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME]; 1663 options[DHO_HOST_NAME]->value = hostname; 1664 options[DHO_HOST_NAME]->len = len; 1665 options[DHO_HOST_NAME]->buf_size = len; 1666 options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF; 1667 } 1668 } 1669 1670 /* set unique client identifier */ 1671 char client_ident[sizeof(ip->hw_address.haddr) + 1]; 1672 if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) { 1673 int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ? 1674 ip->hw_address.hlen : sizeof(client_ident)-1; 1675 client_ident[0] = ip->hw_address.htype; 1676 memcpy(&client_ident[1], ip->hw_address.haddr, hwlen); 1677 options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER]; 1678 options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident; 1679 options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1; 1680 options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1; 1681 options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF; 1682 } 1683 1684 /* Set up the option buffer... */ 1685 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0, 1686 options, 0, 0, 0, NULL, 0); 1687 if (ip->client->packet_length < BOOTP_MIN_LEN) 1688 ip->client->packet_length = BOOTP_MIN_LEN; 1689 1690 ip->client->packet.op = BOOTREQUEST; 1691 ip->client->packet.htype = ip->hw_address.htype; 1692 ip->client->packet.hlen = ip->hw_address.hlen; 1693 ip->client->packet.hops = 0; 1694 ip->client->packet.xid = arc4random(); 1695 ip->client->packet.secs = 0; /* filled in by send_discover. */ 1696 ip->client->packet.flags = 0; 1697 1698 memset(&(ip->client->packet.ciaddr), 1699 0, sizeof(ip->client->packet.ciaddr)); 1700 memset(&(ip->client->packet.yiaddr), 1701 0, sizeof(ip->client->packet.yiaddr)); 1702 memset(&(ip->client->packet.siaddr), 1703 0, sizeof(ip->client->packet.siaddr)); 1704 memset(&(ip->client->packet.giaddr), 1705 0, sizeof(ip->client->packet.giaddr)); 1706 memcpy(ip->client->packet.chaddr, 1707 ip->hw_address.haddr, ip->hw_address.hlen); 1708 } 1709 1710 1711 void 1712 make_request(struct interface_info *ip, struct client_lease * lease) 1713 { 1714 unsigned char request = DHCPREQUEST; 1715 struct tree_cache *options[256]; 1716 struct tree_cache option_elements[256]; 1717 int i; 1718 1719 memset(options, 0, sizeof(options)); 1720 memset(&ip->client->packet, 0, sizeof(ip->client->packet)); 1721 1722 /* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */ 1723 i = DHO_DHCP_MESSAGE_TYPE; 1724 options[i] = &option_elements[i]; 1725 options[i]->value = &request; 1726 options[i]->len = sizeof(request); 1727 options[i]->buf_size = sizeof(request); 1728 options[i]->timeout = 0xFFFFFFFF; 1729 1730 /* Request the options we want */ 1731 i = DHO_DHCP_PARAMETER_REQUEST_LIST; 1732 options[i] = &option_elements[i]; 1733 options[i]->value = ip->client->config->requested_options; 1734 options[i]->len = ip->client->config->requested_option_count; 1735 options[i]->buf_size = 1736 ip->client->config->requested_option_count; 1737 options[i]->timeout = 0xFFFFFFFF; 1738 1739 /* If we are requesting an address that hasn't yet been assigned 1740 to us, use the DHCP Requested Address option. */ 1741 if (ip->client->state == S_REQUESTING) { 1742 /* Send back the server identifier... */ 1743 i = DHO_DHCP_SERVER_IDENTIFIER; 1744 options[i] = &option_elements[i]; 1745 options[i]->value = lease->options[i].data; 1746 options[i]->len = lease->options[i].len; 1747 options[i]->buf_size = lease->options[i].len; 1748 options[i]->timeout = 0xFFFFFFFF; 1749 } 1750 if (ip->client->state == S_REQUESTING || 1751 ip->client->state == S_REBOOTING) { 1752 ip->client->requested_address = lease->address; 1753 i = DHO_DHCP_REQUESTED_ADDRESS; 1754 options[i] = &option_elements[i]; 1755 options[i]->value = lease->address.iabuf; 1756 options[i]->len = lease->address.len; 1757 options[i]->buf_size = lease->address.len; 1758 options[i]->timeout = 0xFFFFFFFF; 1759 } else 1760 ip->client->requested_address.len = 0; 1761 1762 /* Send any options requested in the config file. */ 1763 for (i = 0; i < 256; i++) 1764 if (!options[i] && 1765 ip->client->config->send_options[i].data) { 1766 options[i] = &option_elements[i]; 1767 options[i]->value = 1768 ip->client->config->send_options[i].data; 1769 options[i]->len = 1770 ip->client->config->send_options[i].len; 1771 options[i]->buf_size = 1772 ip->client->config->send_options[i].len; 1773 options[i]->timeout = 0xFFFFFFFF; 1774 } 1775 1776 /* send host name if not set via config file. */ 1777 if (!options[DHO_HOST_NAME]) { 1778 if (hostname[0] != '\0') { 1779 size_t len; 1780 char* posDot = strchr(hostname, '.'); 1781 if (posDot != NULL) 1782 len = posDot - hostname; 1783 else 1784 len = strlen(hostname); 1785 options[DHO_HOST_NAME] = &option_elements[DHO_HOST_NAME]; 1786 options[DHO_HOST_NAME]->value = hostname; 1787 options[DHO_HOST_NAME]->len = len; 1788 options[DHO_HOST_NAME]->buf_size = len; 1789 options[DHO_HOST_NAME]->timeout = 0xFFFFFFFF; 1790 } 1791 } 1792 1793 /* set unique client identifier */ 1794 char client_ident[sizeof(ip->hw_address.haddr) + 1]; 1795 if (!options[DHO_DHCP_CLIENT_IDENTIFIER]) { 1796 int hwlen = (ip->hw_address.hlen < sizeof(client_ident)-1) ? 1797 ip->hw_address.hlen : sizeof(client_ident)-1; 1798 client_ident[0] = ip->hw_address.htype; 1799 memcpy(&client_ident[1], ip->hw_address.haddr, hwlen); 1800 options[DHO_DHCP_CLIENT_IDENTIFIER] = &option_elements[DHO_DHCP_CLIENT_IDENTIFIER]; 1801 options[DHO_DHCP_CLIENT_IDENTIFIER]->value = client_ident; 1802 options[DHO_DHCP_CLIENT_IDENTIFIER]->len = hwlen+1; 1803 options[DHO_DHCP_CLIENT_IDENTIFIER]->buf_size = hwlen+1; 1804 options[DHO_DHCP_CLIENT_IDENTIFIER]->timeout = 0xFFFFFFFF; 1805 } 1806 1807 /* Set up the option buffer... */ 1808 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0, 1809 options, 0, 0, 0, NULL, 0); 1810 if (ip->client->packet_length < BOOTP_MIN_LEN) 1811 ip->client->packet_length = BOOTP_MIN_LEN; 1812 1813 ip->client->packet.op = BOOTREQUEST; 1814 ip->client->packet.htype = ip->hw_address.htype; 1815 ip->client->packet.hlen = ip->hw_address.hlen; 1816 ip->client->packet.hops = 0; 1817 ip->client->packet.xid = ip->client->xid; 1818 ip->client->packet.secs = 0; /* Filled in by send_request. */ 1819 1820 /* If we own the address we're requesting, put it in ciaddr; 1821 otherwise set ciaddr to zero. */ 1822 if (ip->client->state == S_BOUND || 1823 ip->client->state == S_RENEWING || 1824 ip->client->state == S_REBINDING) { 1825 memcpy(&ip->client->packet.ciaddr, 1826 lease->address.iabuf, lease->address.len); 1827 ip->client->packet.flags = 0; 1828 } else { 1829 memset(&ip->client->packet.ciaddr, 0, 1830 sizeof(ip->client->packet.ciaddr)); 1831 ip->client->packet.flags = 0; 1832 } 1833 1834 memset(&ip->client->packet.yiaddr, 0, 1835 sizeof(ip->client->packet.yiaddr)); 1836 memset(&ip->client->packet.siaddr, 0, 1837 sizeof(ip->client->packet.siaddr)); 1838 memset(&ip->client->packet.giaddr, 0, 1839 sizeof(ip->client->packet.giaddr)); 1840 memcpy(ip->client->packet.chaddr, 1841 ip->hw_address.haddr, ip->hw_address.hlen); 1842 } 1843 1844 void 1845 make_decline(struct interface_info *ip, struct client_lease *lease) 1846 { 1847 struct tree_cache *options[256], message_type_tree; 1848 struct tree_cache requested_address_tree; 1849 struct tree_cache server_id_tree, client_id_tree; 1850 unsigned char decline = DHCPDECLINE; 1851 int i; 1852 1853 memset(options, 0, sizeof(options)); 1854 memset(&ip->client->packet, 0, sizeof(ip->client->packet)); 1855 1856 /* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */ 1857 i = DHO_DHCP_MESSAGE_TYPE; 1858 options[i] = &message_type_tree; 1859 options[i]->value = &decline; 1860 options[i]->len = sizeof(decline); 1861 options[i]->buf_size = sizeof(decline); 1862 options[i]->timeout = 0xFFFFFFFF; 1863 1864 /* Send back the server identifier... */ 1865 i = DHO_DHCP_SERVER_IDENTIFIER; 1866 options[i] = &server_id_tree; 1867 options[i]->value = lease->options[i].data; 1868 options[i]->len = lease->options[i].len; 1869 options[i]->buf_size = lease->options[i].len; 1870 options[i]->timeout = 0xFFFFFFFF; 1871 1872 /* Send back the address we're declining. */ 1873 i = DHO_DHCP_REQUESTED_ADDRESS; 1874 options[i] = &requested_address_tree; 1875 options[i]->value = lease->address.iabuf; 1876 options[i]->len = lease->address.len; 1877 options[i]->buf_size = lease->address.len; 1878 options[i]->timeout = 0xFFFFFFFF; 1879 1880 /* Send the uid if the user supplied one. */ 1881 i = DHO_DHCP_CLIENT_IDENTIFIER; 1882 if (ip->client->config->send_options[i].len) { 1883 options[i] = &client_id_tree; 1884 options[i]->value = ip->client->config->send_options[i].data; 1885 options[i]->len = ip->client->config->send_options[i].len; 1886 options[i]->buf_size = ip->client->config->send_options[i].len; 1887 options[i]->timeout = 0xFFFFFFFF; 1888 } 1889 1890 1891 /* Set up the option buffer... */ 1892 ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0, 1893 options, 0, 0, 0, NULL, 0); 1894 if (ip->client->packet_length < BOOTP_MIN_LEN) 1895 ip->client->packet_length = BOOTP_MIN_LEN; 1896 1897 ip->client->packet.op = BOOTREQUEST; 1898 ip->client->packet.htype = ip->hw_address.htype; 1899 ip->client->packet.hlen = ip->hw_address.hlen; 1900 ip->client->packet.hops = 0; 1901 ip->client->packet.xid = ip->client->xid; 1902 ip->client->packet.secs = 0; /* Filled in by send_request. */ 1903 ip->client->packet.flags = 0; 1904 1905 /* ciaddr must always be zero. */ 1906 memset(&ip->client->packet.ciaddr, 0, 1907 sizeof(ip->client->packet.ciaddr)); 1908 memset(&ip->client->packet.yiaddr, 0, 1909 sizeof(ip->client->packet.yiaddr)); 1910 memset(&ip->client->packet.siaddr, 0, 1911 sizeof(ip->client->packet.siaddr)); 1912 memset(&ip->client->packet.giaddr, 0, 1913 sizeof(ip->client->packet.giaddr)); 1914 memcpy(ip->client->packet.chaddr, 1915 ip->hw_address.haddr, ip->hw_address.hlen); 1916 } 1917 1918 void 1919 free_client_lease(struct client_lease *lease) 1920 { 1921 int i; 1922 1923 if (lease->server_name) 1924 free(lease->server_name); 1925 if (lease->filename) 1926 free(lease->filename); 1927 for (i = 0; i < 256; i++) { 1928 if (lease->options[i].len) 1929 free(lease->options[i].data); 1930 } 1931 free(lease); 1932 } 1933 1934 static FILE *leaseFile; 1935 1936 void 1937 rewrite_client_leases(void) 1938 { 1939 struct client_lease *lp; 1940 cap_rights_t rights; 1941 1942 if (!leaseFile) { 1943 leaseFile = fopen(path_dhclient_db, "w"); 1944 if (!leaseFile) 1945 error("can't create %s: %m", path_dhclient_db); 1946 cap_rights_init(&rights, CAP_FCNTL, CAP_FSTAT, CAP_FSYNC, 1947 CAP_FTRUNCATE, CAP_SEEK, CAP_WRITE); 1948 if (caph_rights_limit(fileno(leaseFile), &rights) < 0) { 1949 error("can't limit lease descriptor: %m"); 1950 } 1951 if (caph_fcntls_limit(fileno(leaseFile), CAP_FCNTL_GETFL) < 0) { 1952 error("can't limit lease descriptor fcntls: %m"); 1953 } 1954 } else { 1955 fflush(leaseFile); 1956 rewind(leaseFile); 1957 } 1958 1959 for (lp = ifi->client->leases; lp; lp = lp->next) 1960 write_client_lease(ifi, lp, 1); 1961 if (ifi->client->active) 1962 write_client_lease(ifi, ifi->client->active, 1); 1963 1964 fflush(leaseFile); 1965 ftruncate(fileno(leaseFile), ftello(leaseFile)); 1966 fsync(fileno(leaseFile)); 1967 } 1968 1969 void 1970 write_client_lease(struct interface_info *ip, struct client_lease *lease, 1971 int rewrite) 1972 { 1973 static int leases_written; 1974 struct tm *t; 1975 int i; 1976 1977 if (!rewrite) { 1978 if (leases_written++ > 20) { 1979 rewrite_client_leases(); 1980 leases_written = 0; 1981 } 1982 } 1983 1984 /* If the lease came from the config file, we don't need to stash 1985 a copy in the lease database. */ 1986 if (lease->is_static) 1987 return; 1988 1989 if (!leaseFile) { /* XXX */ 1990 leaseFile = fopen(path_dhclient_db, "w"); 1991 if (!leaseFile) 1992 error("can't create %s: %m", path_dhclient_db); 1993 } 1994 1995 fprintf(leaseFile, "lease {\n"); 1996 if (lease->is_bootp) 1997 fprintf(leaseFile, " bootp;\n"); 1998 fprintf(leaseFile, " interface \"%s\";\n", ip->name); 1999 fprintf(leaseFile, " fixed-address %s;\n", piaddr(lease->address)); 2000 if (lease->nextserver.len == sizeof(inaddr_any) && 2001 0 != memcmp(lease->nextserver.iabuf, &inaddr_any, 2002 sizeof(inaddr_any))) 2003 fprintf(leaseFile, " next-server %s;\n", 2004 piaddr(lease->nextserver)); 2005 if (lease->filename) 2006 fprintf(leaseFile, " filename \"%s\";\n", lease->filename); 2007 if (lease->server_name) 2008 fprintf(leaseFile, " server-name \"%s\";\n", 2009 lease->server_name); 2010 if (lease->medium) 2011 fprintf(leaseFile, " medium \"%s\";\n", lease->medium->string); 2012 for (i = 0; i < 256; i++) 2013 if (lease->options[i].len) 2014 fprintf(leaseFile, " option %s %s;\n", 2015 dhcp_options[i].name, 2016 pretty_print_option(i, lease->options[i].data, 2017 lease->options[i].len, 1, 1)); 2018 2019 t = gmtime(&lease->renewal); 2020 fprintf(leaseFile, " renew %d %d/%d/%d %02d:%02d:%02d;\n", 2021 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 2022 t->tm_hour, t->tm_min, t->tm_sec); 2023 t = gmtime(&lease->rebind); 2024 fprintf(leaseFile, " rebind %d %d/%d/%d %02d:%02d:%02d;\n", 2025 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 2026 t->tm_hour, t->tm_min, t->tm_sec); 2027 t = gmtime(&lease->expiry); 2028 fprintf(leaseFile, " expire %d %d/%d/%d %02d:%02d:%02d;\n", 2029 t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, 2030 t->tm_hour, t->tm_min, t->tm_sec); 2031 fprintf(leaseFile, "}\n"); 2032 fflush(leaseFile); 2033 } 2034 2035 void 2036 script_init(const char *reason, struct string_list *medium) 2037 { 2038 size_t len, mediumlen = 0; 2039 struct imsg_hdr hdr; 2040 struct buf *buf; 2041 int errs; 2042 2043 if (medium != NULL && medium->string != NULL) 2044 mediumlen = strlen(medium->string); 2045 2046 hdr.code = IMSG_SCRIPT_INIT; 2047 hdr.len = sizeof(struct imsg_hdr) + 2048 sizeof(size_t) + mediumlen + 2049 sizeof(size_t) + strlen(reason); 2050 2051 if ((buf = buf_open(hdr.len)) == NULL) 2052 error("buf_open: %m"); 2053 2054 errs = 0; 2055 errs += buf_add(buf, &hdr, sizeof(hdr)); 2056 errs += buf_add(buf, &mediumlen, sizeof(mediumlen)); 2057 if (mediumlen > 0) 2058 errs += buf_add(buf, medium->string, mediumlen); 2059 len = strlen(reason); 2060 errs += buf_add(buf, &len, sizeof(len)); 2061 errs += buf_add(buf, reason, len); 2062 2063 if (errs) 2064 error("buf_add: %m"); 2065 2066 if (buf_close(privfd, buf) == -1) 2067 error("buf_close: %m"); 2068 } 2069 2070 void 2071 priv_script_init(const char *reason, char *medium) 2072 { 2073 struct interface_info *ip = ifi; 2074 2075 if (ip) { 2076 ip->client->scriptEnvsize = 100; 2077 if (ip->client->scriptEnv == NULL) 2078 ip->client->scriptEnv = 2079 malloc(ip->client->scriptEnvsize * sizeof(char *)); 2080 if (ip->client->scriptEnv == NULL) 2081 error("script_init: no memory for environment"); 2082 2083 ip->client->scriptEnv[0] = strdup(CLIENT_PATH); 2084 if (ip->client->scriptEnv[0] == NULL) 2085 error("script_init: no memory for environment"); 2086 2087 ip->client->scriptEnv[1] = NULL; 2088 2089 script_set_env(ip->client, "", "interface", ip->name); 2090 2091 if (medium) 2092 script_set_env(ip->client, "", "medium", medium); 2093 2094 script_set_env(ip->client, "", "reason", reason); 2095 } 2096 } 2097 2098 void 2099 priv_script_write_params(const char *prefix, struct client_lease *lease) 2100 { 2101 struct interface_info *ip = ifi; 2102 u_int8_t dbuf[1500], *dp = NULL; 2103 int i; 2104 size_t len; 2105 char tbuf[128]; 2106 2107 script_set_env(ip->client, prefix, "ip_address", 2108 piaddr(lease->address)); 2109 2110 if (ip->client->config->default_actions[DHO_SUBNET_MASK] == 2111 ACTION_SUPERSEDE) { 2112 dp = ip->client->config->defaults[DHO_SUBNET_MASK].data; 2113 len = ip->client->config->defaults[DHO_SUBNET_MASK].len; 2114 } else { 2115 dp = lease->options[DHO_SUBNET_MASK].data; 2116 len = lease->options[DHO_SUBNET_MASK].len; 2117 } 2118 if (len && (len < sizeof(lease->address.iabuf))) { 2119 struct iaddr netmask, subnet, broadcast; 2120 2121 memcpy(netmask.iabuf, dp, len); 2122 netmask.len = len; 2123 subnet = subnet_number(lease->address, netmask); 2124 if (subnet.len) { 2125 script_set_env(ip->client, prefix, "network_number", 2126 piaddr(subnet)); 2127 if (!lease->options[DHO_BROADCAST_ADDRESS].len) { 2128 broadcast = broadcast_addr(subnet, netmask); 2129 if (broadcast.len) 2130 script_set_env(ip->client, prefix, 2131 "broadcast_address", 2132 piaddr(broadcast)); 2133 } 2134 } 2135 } 2136 2137 if (lease->filename) 2138 script_set_env(ip->client, prefix, "filename", lease->filename); 2139 if (lease->server_name) 2140 script_set_env(ip->client, prefix, "server_name", 2141 lease->server_name); 2142 for (i = 0; i < 256; i++) { 2143 len = 0; 2144 2145 if (ip->client->config->defaults[i].len) { 2146 if (lease->options[i].len) { 2147 switch ( 2148 ip->client->config->default_actions[i]) { 2149 case ACTION_DEFAULT: 2150 dp = lease->options[i].data; 2151 len = lease->options[i].len; 2152 break; 2153 case ACTION_SUPERSEDE: 2154 supersede: 2155 dp = ip->client-> 2156 config->defaults[i].data; 2157 len = ip->client-> 2158 config->defaults[i].len; 2159 break; 2160 case ACTION_PREPEND: 2161 len = ip->client-> 2162 config->defaults[i].len + 2163 lease->options[i].len; 2164 if (len >= sizeof(dbuf)) { 2165 warning("no space to %s %s", 2166 "prepend option", 2167 dhcp_options[i].name); 2168 goto supersede; 2169 } 2170 dp = dbuf; 2171 memcpy(dp, 2172 ip->client-> 2173 config->defaults[i].data, 2174 ip->client-> 2175 config->defaults[i].len); 2176 memcpy(dp + ip->client-> 2177 config->defaults[i].len, 2178 lease->options[i].data, 2179 lease->options[i].len); 2180 dp[len] = '\0'; 2181 break; 2182 case ACTION_APPEND: 2183 /* 2184 * When we append, we assume that we're 2185 * appending to text. Some MS servers 2186 * include a NUL byte at the end of 2187 * the search string provided. 2188 */ 2189 len = ip->client-> 2190 config->defaults[i].len + 2191 lease->options[i].len; 2192 if (len >= sizeof(dbuf)) { 2193 warning("no space to %s %s", 2194 "append option", 2195 dhcp_options[i].name); 2196 goto supersede; 2197 } 2198 memcpy(dbuf, 2199 lease->options[i].data, 2200 lease->options[i].len); 2201 for (dp = dbuf + lease->options[i].len; 2202 dp > dbuf; dp--, len--) 2203 if (dp[-1] != '\0') 2204 break; 2205 memcpy(dp, 2206 ip->client-> 2207 config->defaults[i].data, 2208 ip->client-> 2209 config->defaults[i].len); 2210 dp = dbuf; 2211 dp[len] = '\0'; 2212 } 2213 } else { 2214 dp = ip->client-> 2215 config->defaults[i].data; 2216 len = ip->client-> 2217 config->defaults[i].len; 2218 } 2219 } else if (lease->options[i].len) { 2220 len = lease->options[i].len; 2221 dp = lease->options[i].data; 2222 } else { 2223 len = 0; 2224 } 2225 if (len) { 2226 char name[256]; 2227 2228 if (dhcp_option_ev_name(name, sizeof(name), 2229 &dhcp_options[i])) 2230 script_set_env(ip->client, prefix, name, 2231 pretty_print_option(i, dp, len, 0, 0)); 2232 } 2233 } 2234 snprintf(tbuf, sizeof(tbuf), "%d", (int)lease->expiry); 2235 script_set_env(ip->client, prefix, "expiry", tbuf); 2236 } 2237 2238 void 2239 script_write_params(const char *prefix, struct client_lease *lease) 2240 { 2241 size_t fn_len = 0, sn_len = 0, pr_len = 0; 2242 struct imsg_hdr hdr; 2243 struct buf *buf; 2244 int errs, i; 2245 2246 if (lease->filename != NULL) 2247 fn_len = strlen(lease->filename); 2248 if (lease->server_name != NULL) 2249 sn_len = strlen(lease->server_name); 2250 if (prefix != NULL) 2251 pr_len = strlen(prefix); 2252 2253 hdr.code = IMSG_SCRIPT_WRITE_PARAMS; 2254 hdr.len = sizeof(hdr) + sizeof(*lease) + 2255 sizeof(fn_len) + fn_len + sizeof(sn_len) + sn_len + 2256 sizeof(pr_len) + pr_len; 2257 2258 for (i = 0; i < 256; i++) { 2259 hdr.len += sizeof(lease->options[i].len); 2260 hdr.len += lease->options[i].len; 2261 } 2262 2263 scripttime = time(NULL); 2264 2265 if ((buf = buf_open(hdr.len)) == NULL) 2266 error("buf_open: %m"); 2267 2268 errs = 0; 2269 errs += buf_add(buf, &hdr, sizeof(hdr)); 2270 errs += buf_add(buf, lease, sizeof(*lease)); 2271 errs += buf_add(buf, &fn_len, sizeof(fn_len)); 2272 errs += buf_add(buf, lease->filename, fn_len); 2273 errs += buf_add(buf, &sn_len, sizeof(sn_len)); 2274 errs += buf_add(buf, lease->server_name, sn_len); 2275 errs += buf_add(buf, &pr_len, sizeof(pr_len)); 2276 errs += buf_add(buf, prefix, pr_len); 2277 2278 for (i = 0; i < 256; i++) { 2279 errs += buf_add(buf, &lease->options[i].len, 2280 sizeof(lease->options[i].len)); 2281 errs += buf_add(buf, lease->options[i].data, 2282 lease->options[i].len); 2283 } 2284 2285 if (errs) 2286 error("buf_add: %m"); 2287 2288 if (buf_close(privfd, buf) == -1) 2289 error("buf_close: %m"); 2290 } 2291 2292 int 2293 script_go(void) 2294 { 2295 struct imsg_hdr hdr; 2296 struct buf *buf; 2297 int ret; 2298 2299 hdr.code = IMSG_SCRIPT_GO; 2300 hdr.len = sizeof(struct imsg_hdr); 2301 2302 if ((buf = buf_open(hdr.len)) == NULL) 2303 error("buf_open: %m"); 2304 2305 if (buf_add(buf, &hdr, sizeof(hdr))) 2306 error("buf_add: %m"); 2307 2308 if (buf_close(privfd, buf) == -1) 2309 error("buf_close: %m"); 2310 2311 bzero(&hdr, sizeof(hdr)); 2312 buf_read(privfd, &hdr, sizeof(hdr)); 2313 if (hdr.code != IMSG_SCRIPT_GO_RET) 2314 error("unexpected msg type %u", hdr.code); 2315 if (hdr.len != sizeof(hdr) + sizeof(int)) 2316 error("received corrupted message"); 2317 buf_read(privfd, &ret, sizeof(ret)); 2318 2319 scripttime = time(NULL); 2320 2321 return (ret); 2322 } 2323 2324 int 2325 priv_script_go(void) 2326 { 2327 char *scriptName, *argv[2], **envp, *epp[3], reason[] = "REASON=NBI"; 2328 static char client_path[] = CLIENT_PATH; 2329 struct interface_info *ip = ifi; 2330 int pid, wpid, wstatus; 2331 2332 scripttime = time(NULL); 2333 2334 if (ip) { 2335 scriptName = ip->client->config->script_name; 2336 envp = ip->client->scriptEnv; 2337 } else { 2338 scriptName = top_level_config.script_name; 2339 epp[0] = reason; 2340 epp[1] = client_path; 2341 epp[2] = NULL; 2342 envp = epp; 2343 } 2344 2345 argv[0] = scriptName; 2346 argv[1] = NULL; 2347 2348 pid = fork(); 2349 if (pid < 0) { 2350 error("fork: %m"); 2351 wstatus = 0; 2352 } else if (pid) { 2353 do { 2354 wpid = wait(&wstatus); 2355 } while (wpid != pid && wpid > 0); 2356 if (wpid < 0) { 2357 error("wait: %m"); 2358 wstatus = 0; 2359 } 2360 } else { 2361 execve(scriptName, argv, envp); 2362 error("execve (%s, ...): %m", scriptName); 2363 } 2364 2365 if (ip) 2366 script_flush_env(ip->client); 2367 2368 return (WIFEXITED(wstatus) ? 2369 WEXITSTATUS(wstatus) : 128 + WTERMSIG(wstatus)); 2370 } 2371 2372 void 2373 script_set_env(struct client_state *client, const char *prefix, 2374 const char *name, const char *value) 2375 { 2376 int i, namelen; 2377 size_t j; 2378 2379 /* No `` or $() command substitution allowed in environment values! */ 2380 for (j=0; j < strlen(value); j++) 2381 switch (value[j]) { 2382 case '`': 2383 case '$': 2384 warning("illegal character (%c) in value '%s'", 2385 value[j], value); 2386 /* Ignore this option */ 2387 return; 2388 } 2389 2390 namelen = strlen(name); 2391 2392 for (i = 0; client->scriptEnv[i]; i++) 2393 if (strncmp(client->scriptEnv[i], name, namelen) == 0 && 2394 client->scriptEnv[i][namelen] == '=') 2395 break; 2396 2397 if (client->scriptEnv[i]) 2398 /* Reuse the slot. */ 2399 free(client->scriptEnv[i]); 2400 else { 2401 /* New variable. Expand if necessary. */ 2402 if (i >= client->scriptEnvsize - 1) { 2403 char **newscriptEnv; 2404 int newscriptEnvsize = client->scriptEnvsize + 50; 2405 2406 newscriptEnv = realloc(client->scriptEnv, 2407 newscriptEnvsize); 2408 if (newscriptEnv == NULL) { 2409 free(client->scriptEnv); 2410 client->scriptEnv = NULL; 2411 client->scriptEnvsize = 0; 2412 error("script_set_env: no memory for variable"); 2413 } 2414 client->scriptEnv = newscriptEnv; 2415 client->scriptEnvsize = newscriptEnvsize; 2416 } 2417 /* need to set the NULL pointer at end of array beyond 2418 the new slot. */ 2419 client->scriptEnv[i + 1] = NULL; 2420 } 2421 /* Allocate space and format the variable in the appropriate slot. */ 2422 client->scriptEnv[i] = malloc(strlen(prefix) + strlen(name) + 1 + 2423 strlen(value) + 1); 2424 if (client->scriptEnv[i] == NULL) 2425 error("script_set_env: no memory for variable assignment"); 2426 snprintf(client->scriptEnv[i], strlen(prefix) + strlen(name) + 2427 1 + strlen(value) + 1, "%s%s=%s", prefix, name, value); 2428 } 2429 2430 void 2431 script_flush_env(struct client_state *client) 2432 { 2433 int i; 2434 2435 for (i = 0; client->scriptEnv[i]; i++) { 2436 free(client->scriptEnv[i]); 2437 client->scriptEnv[i] = NULL; 2438 } 2439 client->scriptEnvsize = 0; 2440 } 2441 2442 int 2443 dhcp_option_ev_name(char *buf, size_t buflen, struct option *option) 2444 { 2445 size_t i; 2446 2447 for (i = 0; option->name[i]; i++) { 2448 if (i + 1 == buflen) 2449 return 0; 2450 if (option->name[i] == '-') 2451 buf[i] = '_'; 2452 else 2453 buf[i] = option->name[i]; 2454 } 2455 2456 buf[i] = 0; 2457 return 1; 2458 } 2459 2460 void 2461 go_daemon(void) 2462 { 2463 static int state = 0; 2464 cap_rights_t rights; 2465 2466 if (no_daemon || state) 2467 return; 2468 2469 state = 1; 2470 2471 /* Stop logging to stderr... */ 2472 log_perror = 0; 2473 2474 if (daemonfd(-1, nullfd) == -1) 2475 error("daemon"); 2476 2477 cap_rights_init(&rights); 2478 2479 if (pidfile != NULL) { 2480 pidfile_write(pidfile); 2481 2482 if (caph_rights_limit(pidfile_fileno(pidfile), &rights) < 0) 2483 error("can't limit pidfile descriptor: %m"); 2484 } 2485 2486 if (nullfd != -1) { 2487 close(nullfd); 2488 nullfd = -1; 2489 } 2490 2491 if (caph_rights_limit(STDIN_FILENO, &rights) < 0) 2492 error("can't limit stdin: %m"); 2493 cap_rights_init(&rights, CAP_WRITE); 2494 if (caph_rights_limit(STDOUT_FILENO, &rights) < 0) 2495 error("can't limit stdout: %m"); 2496 if (caph_rights_limit(STDERR_FILENO, &rights) < 0) 2497 error("can't limit stderr: %m"); 2498 } 2499 2500 int 2501 check_option(struct client_lease *l, int option) 2502 { 2503 const char *opbuf; 2504 const char *sbuf; 2505 2506 /* we use this, since this is what gets passed to dhclient-script */ 2507 2508 opbuf = pretty_print_option(option, l->options[option].data, 2509 l->options[option].len, 0, 0); 2510 2511 sbuf = option_as_string(option, l->options[option].data, 2512 l->options[option].len); 2513 2514 switch (option) { 2515 case DHO_SUBNET_MASK: 2516 case DHO_TIME_SERVERS: 2517 case DHO_NAME_SERVERS: 2518 case DHO_ROUTERS: 2519 case DHO_DOMAIN_NAME_SERVERS: 2520 case DHO_LOG_SERVERS: 2521 case DHO_COOKIE_SERVERS: 2522 case DHO_LPR_SERVERS: 2523 case DHO_IMPRESS_SERVERS: 2524 case DHO_RESOURCE_LOCATION_SERVERS: 2525 case DHO_SWAP_SERVER: 2526 case DHO_BROADCAST_ADDRESS: 2527 case DHO_NIS_SERVERS: 2528 case DHO_NTP_SERVERS: 2529 case DHO_NETBIOS_NAME_SERVERS: 2530 case DHO_NETBIOS_DD_SERVER: 2531 case DHO_FONT_SERVERS: 2532 case DHO_DHCP_SERVER_IDENTIFIER: 2533 case DHO_NISPLUS_SERVERS: 2534 case DHO_MOBILE_IP_HOME_AGENT: 2535 case DHO_SMTP_SERVER: 2536 case DHO_POP_SERVER: 2537 case DHO_NNTP_SERVER: 2538 case DHO_WWW_SERVER: 2539 case DHO_FINGER_SERVER: 2540 case DHO_IRC_SERVER: 2541 case DHO_STREETTALK_SERVER: 2542 case DHO_STREETTALK_DA_SERVER: 2543 if (!ipv4addrs(opbuf)) { 2544 warning("Invalid IP address in option: %s", opbuf); 2545 return (0); 2546 } 2547 return (1) ; 2548 case DHO_HOST_NAME: 2549 case DHO_NIS_DOMAIN: 2550 case DHO_NISPLUS_DOMAIN: 2551 case DHO_TFTP_SERVER_NAME: 2552 if (!res_hnok(sbuf)) { 2553 warning("Bogus Host Name option %d: %s (%s)", option, 2554 sbuf, opbuf); 2555 l->options[option].len = 0; 2556 free(l->options[option].data); 2557 } 2558 return (1); 2559 case DHO_DOMAIN_NAME: 2560 case DHO_DOMAIN_SEARCH: 2561 if (!res_hnok(sbuf)) { 2562 if (!check_search(sbuf)) { 2563 warning("Bogus domain search list %d: %s (%s)", 2564 option, sbuf, opbuf); 2565 l->options[option].len = 0; 2566 free(l->options[option].data); 2567 } 2568 } 2569 return (1); 2570 case DHO_PAD: 2571 case DHO_TIME_OFFSET: 2572 case DHO_BOOT_SIZE: 2573 case DHO_MERIT_DUMP: 2574 case DHO_ROOT_PATH: 2575 case DHO_EXTENSIONS_PATH: 2576 case DHO_IP_FORWARDING: 2577 case DHO_NON_LOCAL_SOURCE_ROUTING: 2578 case DHO_POLICY_FILTER: 2579 case DHO_MAX_DGRAM_REASSEMBLY: 2580 case DHO_DEFAULT_IP_TTL: 2581 case DHO_PATH_MTU_AGING_TIMEOUT: 2582 case DHO_PATH_MTU_PLATEAU_TABLE: 2583 case DHO_INTERFACE_MTU: 2584 case DHO_ALL_SUBNETS_LOCAL: 2585 case DHO_PERFORM_MASK_DISCOVERY: 2586 case DHO_MASK_SUPPLIER: 2587 case DHO_ROUTER_DISCOVERY: 2588 case DHO_ROUTER_SOLICITATION_ADDRESS: 2589 case DHO_STATIC_ROUTES: 2590 case DHO_TRAILER_ENCAPSULATION: 2591 case DHO_ARP_CACHE_TIMEOUT: 2592 case DHO_IEEE802_3_ENCAPSULATION: 2593 case DHO_DEFAULT_TCP_TTL: 2594 case DHO_TCP_KEEPALIVE_INTERVAL: 2595 case DHO_TCP_KEEPALIVE_GARBAGE: 2596 case DHO_VENDOR_ENCAPSULATED_OPTIONS: 2597 case DHO_NETBIOS_NODE_TYPE: 2598 case DHO_NETBIOS_SCOPE: 2599 case DHO_X_DISPLAY_MANAGER: 2600 case DHO_DHCP_REQUESTED_ADDRESS: 2601 case DHO_DHCP_LEASE_TIME: 2602 case DHO_DHCP_OPTION_OVERLOAD: 2603 case DHO_DHCP_MESSAGE_TYPE: 2604 case DHO_DHCP_PARAMETER_REQUEST_LIST: 2605 case DHO_DHCP_MESSAGE: 2606 case DHO_DHCP_MAX_MESSAGE_SIZE: 2607 case DHO_DHCP_RENEWAL_TIME: 2608 case DHO_DHCP_REBINDING_TIME: 2609 case DHO_DHCP_CLASS_IDENTIFIER: 2610 case DHO_DHCP_CLIENT_IDENTIFIER: 2611 case DHO_BOOTFILE_NAME: 2612 case DHO_DHCP_USER_CLASS_ID: 2613 case DHO_URL: 2614 case DHO_END: 2615 return (1); 2616 case DHO_CLASSLESS_ROUTES: 2617 return (check_classless_option(l->options[option].data, 2618 l->options[option].len)); 2619 default: 2620 warning("unknown dhcp option value 0x%x", option); 2621 return (unknown_ok); 2622 } 2623 } 2624 2625 /* RFC 3442 The Classless Static Routes option checks */ 2626 int 2627 check_classless_option(unsigned char *data, int len) 2628 { 2629 int i = 0; 2630 unsigned char width; 2631 in_addr_t addr, mask; 2632 2633 if (len < 5) { 2634 warning("Too small length: %d", len); 2635 return (0); 2636 } 2637 while(i < len) { 2638 width = data[i++]; 2639 if (width == 0) { 2640 i += 4; 2641 continue; 2642 } else if (width < 9) { 2643 addr = (in_addr_t)(data[i] << 24); 2644 i += 1; 2645 } else if (width < 17) { 2646 addr = (in_addr_t)(data[i] << 24) + 2647 (in_addr_t)(data[i + 1] << 16); 2648 i += 2; 2649 } else if (width < 25) { 2650 addr = (in_addr_t)(data[i] << 24) + 2651 (in_addr_t)(data[i + 1] << 16) + 2652 (in_addr_t)(data[i + 2] << 8); 2653 i += 3; 2654 } else if (width < 33) { 2655 addr = (in_addr_t)(data[i] << 24) + 2656 (in_addr_t)(data[i + 1] << 16) + 2657 (in_addr_t)(data[i + 2] << 8) + 2658 data[i + 3]; 2659 i += 4; 2660 } else { 2661 warning("Incorrect subnet width: %d", width); 2662 return (0); 2663 } 2664 mask = (in_addr_t)(~0) << (32 - width); 2665 addr = ntohl(addr); 2666 mask = ntohl(mask); 2667 2668 /* 2669 * From RFC 3442: 2670 * ... After deriving a subnet number and subnet mask 2671 * from each destination descriptor, the DHCP client 2672 * MUST zero any bits in the subnet number where the 2673 * corresponding bit in the mask is zero... 2674 */ 2675 if ((addr & mask) != addr) { 2676 addr &= mask; 2677 data[i - 1] = (unsigned char)( 2678 (addr >> (((32 - width)/8)*8)) & 0xFF); 2679 } 2680 i += 4; 2681 } 2682 if (i > len) { 2683 warning("Incorrect data length: %d (must be %d)", len, i); 2684 return (0); 2685 } 2686 return (1); 2687 } 2688 2689 int 2690 res_hnok(const char *dn) 2691 { 2692 int pch = PERIOD, ch = *dn++; 2693 2694 while (ch != '\0') { 2695 int nch = *dn++; 2696 2697 if (periodchar(ch)) { 2698 ; 2699 } else if (periodchar(pch)) { 2700 if (!borderchar(ch)) 2701 return (0); 2702 } else if (periodchar(nch) || nch == '\0') { 2703 if (!borderchar(ch)) 2704 return (0); 2705 } else { 2706 if (!middlechar(ch)) 2707 return (0); 2708 } 2709 pch = ch, ch = nch; 2710 } 2711 return (1); 2712 } 2713 2714 int 2715 check_search(const char *srch) 2716 { 2717 int pch = PERIOD, ch = *srch++; 2718 int domains = 1; 2719 2720 /* 256 char limit re resolv.conf(5) */ 2721 if (strlen(srch) > 256) 2722 return (0); 2723 2724 while (whitechar(ch)) 2725 ch = *srch++; 2726 2727 while (ch != '\0') { 2728 int nch = *srch++; 2729 2730 if (periodchar(ch) || whitechar(ch)) { 2731 ; 2732 } else if (periodchar(pch)) { 2733 if (!borderchar(ch)) 2734 return (0); 2735 } else if (periodchar(nch) || nch == '\0') { 2736 if (!borderchar(ch)) 2737 return (0); 2738 } else { 2739 if (!middlechar(ch)) 2740 return (0); 2741 } 2742 if (!whitechar(ch)) { 2743 pch = ch; 2744 } else { 2745 while (whitechar(nch)) { 2746 nch = *srch++; 2747 } 2748 if (nch != '\0') 2749 domains++; 2750 pch = PERIOD; 2751 } 2752 ch = nch; 2753 } 2754 /* 6 domain limit re resolv.conf(5) */ 2755 if (domains > 6) 2756 return (0); 2757 return (1); 2758 } 2759 2760 /* Does buf consist only of dotted decimal ipv4 addrs? 2761 * return how many if so, 2762 * otherwise, return 0 2763 */ 2764 int 2765 ipv4addrs(const char * buf) 2766 { 2767 struct in_addr jnk; 2768 int count = 0; 2769 2770 while (inet_aton(buf, &jnk) == 1){ 2771 count++; 2772 while (periodchar(*buf) || digitchar(*buf)) 2773 buf++; 2774 if (*buf == '\0') 2775 return (count); 2776 while (*buf == ' ') 2777 buf++; 2778 } 2779 return (0); 2780 } 2781 2782 2783 const char * 2784 option_as_string(unsigned int code, unsigned char *data, int len) 2785 { 2786 static char optbuf[32768]; /* XXX */ 2787 char *op = optbuf; 2788 int opleft = sizeof(optbuf); 2789 unsigned char *dp = data; 2790 2791 if (code > 255) 2792 error("option_as_string: bad code %d", code); 2793 2794 for (; dp < data + len; dp++) { 2795 if (!isascii(*dp) || !isprint(*dp)) { 2796 if (dp + 1 != data + len || *dp != 0) { 2797 snprintf(op, opleft, "\\%03o", *dp); 2798 op += 4; 2799 opleft -= 4; 2800 } 2801 } else if (*dp == '"' || *dp == '\'' || *dp == '$' || 2802 *dp == '`' || *dp == '\\') { 2803 *op++ = '\\'; 2804 *op++ = *dp; 2805 opleft -= 2; 2806 } else { 2807 *op++ = *dp; 2808 opleft--; 2809 } 2810 } 2811 if (opleft < 1) 2812 goto toobig; 2813 *op = 0; 2814 return optbuf; 2815 toobig: 2816 warning("dhcp option too large"); 2817 return "<error>"; 2818 } 2819 2820 int 2821 fork_privchld(int fd, int fd2) 2822 { 2823 struct pollfd pfd[1]; 2824 int nfds; 2825 2826 switch (fork()) { 2827 case -1: 2828 error("cannot fork"); 2829 case 0: 2830 break; 2831 default: 2832 return (0); 2833 } 2834 2835 setproctitle("%s [priv]", ifi->name); 2836 2837 setsid(); 2838 dup2(nullfd, STDIN_FILENO); 2839 dup2(nullfd, STDOUT_FILENO); 2840 dup2(nullfd, STDERR_FILENO); 2841 close(nullfd); 2842 close(fd2); 2843 close(ifi->rfdesc); 2844 ifi->rfdesc = -1; 2845 2846 for (;;) { 2847 pfd[0].fd = fd; 2848 pfd[0].events = POLLIN; 2849 if ((nfds = poll(pfd, 1, INFTIM)) == -1) 2850 if (errno != EINTR) 2851 error("poll error"); 2852 2853 if (nfds == 0 || !(pfd[0].revents & POLLIN)) 2854 continue; 2855 2856 dispatch_imsg(ifi, fd); 2857 } 2858 } 2859