1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2016-2017, Chris Fraire <cfraire@me.com>. 24 */ 25 26 #include <unistd.h> 27 #include <sys/types.h> 28 #include <sys/stat.h> 29 #include <sys/utsname.h> 30 #include <stdlib.h> 31 #include <netinet/in.h> /* struct in_addr */ 32 #include <netinet/dhcp.h> 33 #include <signal.h> 34 #include <sys/socket.h> 35 #include <net/route.h> 36 #include <net/if_arp.h> 37 #include <string.h> 38 #include <dhcpmsg.h> 39 #include <ctype.h> 40 #include <arpa/inet.h> 41 #include <arpa/nameser.h> 42 #include <resolv.h> 43 #include <netdb.h> 44 #include <fcntl.h> 45 #include <stdio.h> 46 #include <dhcp_hostconf.h> 47 #include <dhcp_inittab.h> 48 #include <dhcp_symbol.h> 49 #include <limits.h> 50 #include <strings.h> 51 #include <libipadm.h> 52 53 #include "states.h" 54 #include "agent.h" 55 #include "interface.h" 56 #include "util.h" 57 #include "packet.h" 58 #include "defaults.h" 59 60 /* 61 * this file contains utility functions that have no real better home 62 * of their own. they can largely be broken into six categories: 63 * 64 * o conversion functions -- functions to turn integers into strings, 65 * or to convert between units of a similar measure. 66 * 67 * o time and timer functions -- functions to handle time measurement 68 * and events. 69 * 70 * o ipc-related functions -- functions to simplify the generation of 71 * ipc messages to the agent's clients. 72 * 73 * o signal-related functions -- functions to clean up the agent when 74 * it receives a signal. 75 * 76 * o routing table manipulation functions 77 * 78 * o true miscellany -- anything else 79 */ 80 81 #define ETCNODENAME "/etc/nodename" 82 83 static boolean_t is_fqdn(const char *); 84 static boolean_t dhcp_assemble_fqdn(char *fqdnbuf, size_t buflen, 85 dhcp_smach_t *dsmp); 86 87 /* 88 * pkt_type_to_string(): stringifies a packet type 89 * 90 * input: uchar_t: a DHCP packet type value, RFC 2131 or 3315 91 * boolean_t: B_TRUE if IPv6 92 * output: const char *: the stringified packet type 93 */ 94 95 const char * 96 pkt_type_to_string(uchar_t type, boolean_t isv6) 97 { 98 /* 99 * note: the ordering in these arrays allows direct indexing of the 100 * table based on the RFC packet type value passed in. 101 */ 102 103 static const char *v4types[] = { 104 "BOOTP", "DISCOVER", "OFFER", "REQUEST", "DECLINE", 105 "ACK", "NAK", "RELEASE", "INFORM" 106 }; 107 static const char *v6types[] = { 108 NULL, "SOLICIT", "ADVERTISE", "REQUEST", 109 "CONFIRM", "RENEW", "REBIND", "REPLY", 110 "RELEASE", "DECLINE", "RECONFIGURE", "INFORMATION-REQUEST", 111 "RELAY-FORW", "RELAY-REPL" 112 }; 113 114 if (isv6) { 115 if (type >= sizeof (v6types) / sizeof (*v6types) || 116 v6types[type] == NULL) 117 return ("<unknown>"); 118 else 119 return (v6types[type]); 120 } else { 121 if (type >= sizeof (v4types) / sizeof (*v4types) || 122 v4types[type] == NULL) 123 return ("<unknown>"); 124 else 125 return (v4types[type]); 126 } 127 } 128 129 /* 130 * monosec_to_string(): converts a monosec_t into a date string 131 * 132 * input: monosec_t: the monosec_t to convert 133 * output: const char *: the corresponding date string 134 */ 135 136 const char * 137 monosec_to_string(monosec_t monosec) 138 { 139 time_t time = monosec_to_time(monosec); 140 char *time_string = ctime(&time); 141 142 /* strip off the newline -- ugh, why, why, why.. */ 143 time_string[strlen(time_string) - 1] = '\0'; 144 return (time_string); 145 } 146 147 /* 148 * monosec(): returns a monotonically increasing time in seconds that 149 * is not affected by stime(2) or adjtime(2). 150 * 151 * input: void 152 * output: monosec_t: the number of seconds since some time in the past 153 */ 154 155 monosec_t 156 monosec(void) 157 { 158 return (gethrtime() / NANOSEC); 159 } 160 161 /* 162 * monosec_to_time(): converts a monosec_t into real wall time 163 * 164 * input: monosec_t: the absolute monosec_t to convert 165 * output: time_t: the absolute time that monosec_t represents in wall time 166 */ 167 168 time_t 169 monosec_to_time(monosec_t abs_monosec) 170 { 171 return (abs_monosec - monosec()) + time(NULL); 172 } 173 174 /* 175 * hrtime_to_monosec(): converts a hrtime_t to monosec_t 176 * 177 * input: hrtime_t: the time to convert 178 * output: monosec_t: the time in monosec_t 179 */ 180 181 monosec_t 182 hrtime_to_monosec(hrtime_t hrtime) 183 { 184 return (hrtime / NANOSEC); 185 } 186 187 /* 188 * print_server_msg(): prints a message from a DHCP server 189 * 190 * input: dhcp_smach_t *: the state machine the message is associated with 191 * const char *: the string to display 192 * uint_t: length of string 193 * output: void 194 */ 195 196 void 197 print_server_msg(dhcp_smach_t *dsmp, const char *msg, uint_t msglen) 198 { 199 if (msglen > 0) { 200 dhcpmsg(MSG_INFO, "%s: message from server: %.*s", 201 dsmp->dsm_name, msglen, msg); 202 } 203 } 204 205 /* 206 * alrm_exit(): Signal handler for SIGARLM. terminates grandparent. 207 * 208 * input: int: signal the handler was called with. 209 * 210 * output: void 211 */ 212 213 static void 214 alrm_exit(int sig) 215 { 216 int exitval; 217 218 if (sig == SIGALRM && grandparent != 0) 219 exitval = EXIT_SUCCESS; 220 else 221 exitval = EXIT_FAILURE; 222 223 _exit(exitval); 224 } 225 226 /* 227 * daemonize(): daemonizes the process 228 * 229 * input: void 230 * output: int: 1 on success, 0 on failure 231 */ 232 233 int 234 daemonize(void) 235 { 236 /* 237 * We've found that adoption takes sufficiently long that 238 * a dhcpinfo run after dhcpagent -a is started may occur 239 * before the agent is ready to process the request. 240 * The result is an error message and an unhappy user. 241 * 242 * The initial process now sleeps for DHCP_ADOPT_SLEEP, 243 * unless interrupted by a SIGALRM, in which case it 244 * exits immediately. This has the effect that the 245 * grandparent doesn't exit until the dhcpagent is ready 246 * to process requests. This defers the the balance of 247 * the system start-up script processing until the 248 * dhcpagent is ready to field requests. 249 * 250 * grandparent is only set for the adopt case; other 251 * cases do not require the wait. 252 */ 253 254 if (grandparent != 0) 255 (void) signal(SIGALRM, alrm_exit); 256 257 switch (fork()) { 258 259 case -1: 260 return (0); 261 262 case 0: 263 if (grandparent != 0) 264 (void) signal(SIGALRM, SIG_DFL); 265 266 /* 267 * setsid() makes us lose our controlling terminal, 268 * and become both a session leader and a process 269 * group leader. 270 */ 271 272 (void) setsid(); 273 274 /* 275 * under POSIX, a session leader can accidentally 276 * (through open(2)) acquire a controlling terminal if 277 * it does not have one. just to be safe, fork again 278 * so we are not a session leader. 279 */ 280 281 switch (fork()) { 282 283 case -1: 284 return (0); 285 286 case 0: 287 (void) signal(SIGHUP, SIG_IGN); 288 (void) chdir("/"); 289 (void) umask(022); 290 closefrom(0); 291 break; 292 293 default: 294 _exit(EXIT_SUCCESS); 295 } 296 break; 297 298 default: 299 if (grandparent != 0) { 300 (void) signal(SIGCHLD, SIG_IGN); 301 /* 302 * Note that we're not the agent here, so the DHCP 303 * logging subsystem hasn't been configured yet. 304 */ 305 syslog(LOG_DEBUG | LOG_DAEMON, "dhcpagent: daemonize: " 306 "waiting for adoption to complete."); 307 if (sleep(DHCP_ADOPT_SLEEP) == 0) { 308 syslog(LOG_WARNING | LOG_DAEMON, 309 "dhcpagent: daemonize: timed out awaiting " 310 "adoption."); 311 } 312 syslog(LOG_DEBUG | LOG_DAEMON, "dhcpagent: daemonize: " 313 "wait finished"); 314 } 315 _exit(EXIT_SUCCESS); 316 } 317 318 return (1); 319 } 320 321 /* 322 * update_default_route(): update the interface's default route 323 * 324 * input: int: the type of message; either RTM_ADD or RTM_DELETE 325 * struct in_addr: the default gateway to use 326 * const char *: the interface associated with the route 327 * int: any additional flags (besides RTF_STATIC and RTF_GATEWAY) 328 * output: boolean_t: B_TRUE on success, B_FALSE on failure 329 */ 330 331 static boolean_t 332 update_default_route(uint32_t ifindex, int type, struct in_addr *gateway_nbo, 333 int flags) 334 { 335 struct { 336 struct rt_msghdr rm_mh; 337 struct sockaddr_in rm_dst; 338 struct sockaddr_in rm_gw; 339 struct sockaddr_in rm_mask; 340 struct sockaddr_dl rm_ifp; 341 } rtmsg; 342 343 (void) memset(&rtmsg, 0, sizeof (rtmsg)); 344 rtmsg.rm_mh.rtm_version = RTM_VERSION; 345 rtmsg.rm_mh.rtm_msglen = sizeof (rtmsg); 346 rtmsg.rm_mh.rtm_type = type; 347 rtmsg.rm_mh.rtm_pid = getpid(); 348 rtmsg.rm_mh.rtm_flags = RTF_GATEWAY | RTF_STATIC | flags; 349 rtmsg.rm_mh.rtm_addrs = RTA_GATEWAY | RTA_DST | RTA_NETMASK | RTA_IFP; 350 351 rtmsg.rm_gw.sin_family = AF_INET; 352 rtmsg.rm_gw.sin_addr = *gateway_nbo; 353 354 rtmsg.rm_dst.sin_family = AF_INET; 355 rtmsg.rm_dst.sin_addr.s_addr = htonl(INADDR_ANY); 356 357 rtmsg.rm_mask.sin_family = AF_INET; 358 rtmsg.rm_mask.sin_addr.s_addr = htonl(0); 359 360 rtmsg.rm_ifp.sdl_family = AF_LINK; 361 rtmsg.rm_ifp.sdl_index = ifindex; 362 363 return (write(rtsock_fd, &rtmsg, sizeof (rtmsg)) == sizeof (rtmsg)); 364 } 365 366 /* 367 * add_default_route(): add the default route to the given gateway 368 * 369 * input: const char *: the name of the interface associated with the route 370 * struct in_addr: the default gateway to add 371 * output: boolean_t: B_TRUE on success, B_FALSE otherwise 372 */ 373 374 boolean_t 375 add_default_route(uint32_t ifindex, struct in_addr *gateway_nbo) 376 { 377 return (update_default_route(ifindex, RTM_ADD, gateway_nbo, RTF_UP)); 378 } 379 380 /* 381 * del_default_route(): deletes the default route to the given gateway 382 * 383 * input: const char *: the name of the interface associated with the route 384 * struct in_addr: if not INADDR_ANY, the default gateway to remove 385 * output: boolean_t: B_TRUE on success, B_FALSE on failure 386 */ 387 388 boolean_t 389 del_default_route(uint32_t ifindex, struct in_addr *gateway_nbo) 390 { 391 if (gateway_nbo->s_addr == htonl(INADDR_ANY)) /* no router */ 392 return (B_TRUE); 393 394 return (update_default_route(ifindex, RTM_DELETE, gateway_nbo, 0)); 395 } 396 397 /* 398 * inactivity_shutdown(): shuts down agent if there are no state machines left 399 * to manage 400 * 401 * input: iu_tq_t *: unused 402 * void *: unused 403 * output: void 404 */ 405 406 /* ARGSUSED */ 407 void 408 inactivity_shutdown(iu_tq_t *tqp, void *arg) 409 { 410 if (smach_count() > 0) /* shouldn't happen, but... */ 411 return; 412 413 dhcpmsg(MSG_VERBOSE, "inactivity_shutdown: timed out"); 414 415 iu_stop_handling_events(eh, DHCP_REASON_INACTIVITY, NULL, NULL); 416 } 417 418 /* 419 * graceful_shutdown(): shuts down the agent gracefully 420 * 421 * input: int: the signal that caused graceful_shutdown to be called 422 * output: void 423 */ 424 425 void 426 graceful_shutdown(int sig) 427 { 428 iu_stop_handling_events(eh, (sig == SIGTERM ? DHCP_REASON_TERMINATE : 429 DHCP_REASON_SIGNAL), drain_script, NULL); 430 } 431 432 /* 433 * bind_sock(): binds a socket to a given IP address and port number 434 * 435 * input: int: the socket to bind 436 * in_port_t: the port number to bind to, host byte order 437 * in_addr_t: the address to bind to, host byte order 438 * output: boolean_t: B_TRUE on success, B_FALSE on failure 439 */ 440 441 boolean_t 442 bind_sock(int fd, in_port_t port_hbo, in_addr_t addr_hbo) 443 { 444 struct sockaddr_in sin; 445 int on = 1; 446 447 (void) memset(&sin, 0, sizeof (struct sockaddr_in)); 448 sin.sin_family = AF_INET; 449 sin.sin_port = htons(port_hbo); 450 sin.sin_addr.s_addr = htonl(addr_hbo); 451 452 (void) setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (int)); 453 454 return (bind(fd, (struct sockaddr *)&sin, sizeof (sin)) == 0); 455 } 456 457 /* 458 * bind_sock_v6(): binds a socket to a given IP address and port number 459 * 460 * input: int: the socket to bind 461 * in_port_t: the port number to bind to, host byte order 462 * in6_addr_t: the address to bind to, network byte order 463 * output: boolean_t: B_TRUE on success, B_FALSE on failure 464 */ 465 466 boolean_t 467 bind_sock_v6(int fd, in_port_t port_hbo, const in6_addr_t *addr_nbo) 468 { 469 struct sockaddr_in6 sin6; 470 int on = 1; 471 472 (void) memset(&sin6, 0, sizeof (struct sockaddr_in6)); 473 sin6.sin6_family = AF_INET6; 474 sin6.sin6_port = htons(port_hbo); 475 if (addr_nbo != NULL) { 476 (void) memcpy(&sin6.sin6_addr, addr_nbo, 477 sizeof (sin6.sin6_addr)); 478 } 479 480 (void) setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (int)); 481 482 return (bind(fd, (struct sockaddr *)&sin6, sizeof (sin6)) == 0); 483 } 484 485 /* 486 * iffile_to_hostname(): return the hostname contained on a line of the form 487 * 488 * [ ^I]*inet[ ^I]+hostname[\n]*\0 489 * 490 * in the file located at the specified path 491 * 492 * input: const char *: the path of the file to look in for the hostname 493 * output: const char *: the hostname at that path, or NULL on failure 494 */ 495 496 #define IFLINE_MAX 1024 /* maximum length of a hostname.<if> line */ 497 498 const char * 499 iffile_to_hostname(const char *path) 500 { 501 FILE *fp; 502 static char ifline[IFLINE_MAX]; 503 504 fp = fopen(path, "r"); 505 if (fp == NULL) 506 return (NULL); 507 508 /* 509 * /etc/hostname.<if> may contain multiple ifconfig commands, but each 510 * such command is on a separate line (see the "while read ifcmds" code 511 * in /etc/init.d/inetinit). Thus we will read the file a line at a 512 * time, searching for a line of the form 513 * 514 * [ ^I]*inet[ ^I]+hostname[\n]*\0 515 * 516 * extract the host name from it, and check it for validity. 517 */ 518 while (fgets(ifline, sizeof (ifline), fp) != NULL) { 519 char *p; 520 521 if ((p = strstr(ifline, "inet")) != NULL) { 522 if ((p != ifline) && !isspace(p[-1])) { 523 (void) fclose(fp); 524 return (NULL); 525 } 526 p += 4; /* skip over "inet" and expect spaces or tabs */ 527 if ((*p == '\n') || (*p == '\0')) { 528 (void) fclose(fp); 529 return (NULL); 530 } 531 if (isspace(*p)) { 532 char *nlptr; 533 534 /* no need to read more of the file */ 535 (void) fclose(fp); 536 537 while (isspace(*p)) 538 p++; 539 if ((nlptr = strrchr(p, '\n')) != NULL) 540 *nlptr = '\0'; 541 if (strlen(p) > MAXHOSTNAMELEN) { 542 dhcpmsg(MSG_WARNING, 543 "iffile_to_hostname:" 544 " host name too long"); 545 return (NULL); 546 } 547 if (ipadm_is_valid_hostname(p)) { 548 return (p); 549 } else { 550 dhcpmsg(MSG_WARNING, 551 "iffile_to_hostname:" 552 " host name not valid"); 553 return (NULL); 554 } 555 } else { 556 (void) fclose(fp); 557 return (NULL); 558 } 559 } 560 } 561 562 (void) fclose(fp); 563 return (NULL); 564 } 565 566 /* 567 * init_timer(): set up a DHCP timer 568 * 569 * input: dhcp_timer_t *: the timer to set up 570 * output: void 571 */ 572 573 void 574 init_timer(dhcp_timer_t *dt, lease_t startval) 575 { 576 dt->dt_id = -1; 577 dt->dt_start = startval; 578 } 579 580 /* 581 * cancel_timer(): cancel a DHCP timer 582 * 583 * input: dhcp_timer_t *: the timer to cancel 584 * output: boolean_t: B_TRUE on success, B_FALSE otherwise 585 */ 586 587 boolean_t 588 cancel_timer(dhcp_timer_t *dt) 589 { 590 if (dt->dt_id == -1) 591 return (B_TRUE); 592 593 if (iu_cancel_timer(tq, dt->dt_id, NULL) == 1) { 594 dt->dt_id = -1; 595 return (B_TRUE); 596 } 597 598 return (B_FALSE); 599 } 600 601 /* 602 * schedule_timer(): schedule a DHCP timer. Note that it must not be already 603 * running, and that we can't cancel here. If it were, and 604 * we did, we'd leak a reference to the callback argument. 605 * 606 * input: dhcp_timer_t *: the timer to schedule 607 * output: boolean_t: B_TRUE on success, B_FALSE otherwise 608 */ 609 610 boolean_t 611 schedule_timer(dhcp_timer_t *dt, iu_tq_callback_t *cbfunc, void *arg) 612 { 613 if (dt->dt_id != -1) 614 return (B_FALSE); 615 dt->dt_id = iu_schedule_timer(tq, dt->dt_start, cbfunc, arg); 616 return (dt->dt_id != -1); 617 } 618 619 /* 620 * dhcpv6_status_code(): report on a DHCPv6 status code found in an option 621 * buffer. 622 * 623 * input: const dhcpv6_option_t *: pointer to option 624 * uint_t: option length 625 * const char **: error string (nul-terminated) 626 * const char **: message from server (unterminated) 627 * uint_t *: length of server message 628 * output: int: -1 on error, or >= 0 for a DHCPv6 status code 629 */ 630 631 int 632 dhcpv6_status_code(const dhcpv6_option_t *d6o, uint_t olen, const char **estr, 633 const char **msg, uint_t *msglenp) 634 { 635 uint16_t status; 636 static const char *v6_status[] = { 637 NULL, 638 "Unknown reason", 639 "Server has no addresses available", 640 "Client record unavailable", 641 "Prefix inappropriate for link", 642 "Client must use multicast", 643 "No prefix available" 644 }; 645 static char sbuf[32]; 646 647 *estr = ""; 648 *msg = ""; 649 *msglenp = 0; 650 if (d6o == NULL) 651 return (0); 652 olen -= sizeof (*d6o); 653 if (olen < 2) { 654 *estr = "garbled status code"; 655 return (-1); 656 } 657 658 *msg = (const char *)(d6o + 1) + 2; 659 *msglenp = olen - 2; 660 661 (void) memcpy(&status, d6o + 1, sizeof (status)); 662 status = ntohs(status); 663 if (status > 0) { 664 if (status > DHCPV6_STAT_NOPREFIX) { 665 (void) snprintf(sbuf, sizeof (sbuf), "status %u", 666 status); 667 *estr = sbuf; 668 } else { 669 *estr = v6_status[status]; 670 } 671 } 672 return (status); 673 } 674 675 void 676 write_lease_to_hostconf(dhcp_smach_t *dsmp) 677 { 678 PKT_LIST *plp[2]; 679 const char *hcfile; 680 681 hcfile = ifname_to_hostconf(dsmp->dsm_name, dsmp->dsm_isv6); 682 plp[0] = dsmp->dsm_ack; 683 plp[1] = dsmp->dsm_orig_ack; 684 if (write_hostconf(dsmp->dsm_name, plp, 2, 685 monosec_to_time(dsmp->dsm_curstart_monosec), 686 dsmp->dsm_isv6) != -1) { 687 dhcpmsg(MSG_DEBUG, "wrote lease to %s", hcfile); 688 } else if (errno == EROFS) { 689 dhcpmsg(MSG_DEBUG, "%s is on a read-only file " 690 "system; not saving lease", hcfile); 691 } else { 692 dhcpmsg(MSG_ERR, "cannot write %s (reboot will " 693 "not use cached configuration)", hcfile); 694 } 695 } 696 697 /* 698 * Try to get a string from the first line of a file, up to but not 699 * including any space (0x20) or newline. 700 * 701 * input: const char *: file name; 702 * char *: allocated buffer space; 703 * size_t: space available in buf; 704 * output: boolean_t: B_TRUE if a non-empty string was written to buf; 705 * B_FALSE otherwise. 706 */ 707 708 static boolean_t 709 dhcp_get_oneline(const char *filename, char *buf, size_t buflen) 710 { 711 char value[SYS_NMLN], *c; 712 int fd, i; 713 714 if ((fd = open(filename, O_RDONLY)) <= 0) { 715 dhcpmsg(MSG_DEBUG, "dhcp_get_oneline: could not open %s", 716 filename); 717 *buf = '\0'; 718 } else { 719 if ((i = read(fd, value, SYS_NMLN - 1)) <= 0) { 720 dhcpmsg(MSG_WARNING, "dhcp_get_oneline: no line in %s", 721 filename); 722 *buf = '\0'; 723 } else { 724 value[i] = '\0'; 725 if ((c = strchr(value, '\n')) != NULL) 726 *c = '\0'; 727 if ((c = strchr(value, ' ')) != NULL) 728 *c = '\0'; 729 730 if (strlcpy(buf, value, buflen) >= buflen) { 731 dhcpmsg(MSG_WARNING, "dhcp_get_oneline: too" 732 " long value, %s", value); 733 *buf = '\0'; 734 } 735 } 736 (void) close(fd); 737 } 738 739 return (*buf != '\0'); 740 } 741 742 /* 743 * Try to get the hostname from the /etc/nodename file. uname(2) cannot 744 * be used, because that is initialized after DHCP has solicited, in order 745 * to allow for the possibility that utsname.nodename can be set from 746 * DHCP Hostname. Here, though, we want to send a value specified 747 * advance of DHCP, so read /etc/nodename directly. 748 * 749 * input: char *: allocated buffer space; 750 * size_t: space available in buf; 751 * output: boolean_t: B_TRUE if a non-empty string was written to buf; 752 * B_FALSE otherwise. 753 */ 754 755 static boolean_t 756 dhcp_get_nodename(char *buf, size_t buflen) 757 { 758 return (dhcp_get_oneline(ETCNODENAME, buf, buflen)); 759 } 760 761 /* 762 * dhcp_add_hostname_opt(): Set CD_HOSTNAME option if REQUEST_HOSTNAME is 763 * affirmative and if 1) dsm_msg_reqhost is available; 764 * or 2) hostname is read from an extant 765 * /etc/hostname.<ifname> file; or 3) interface is 766 * primary and nodename(4) is defined. 767 * 768 * input: dhcp_pkt_t *: pointer to DHCP message being constructed; 769 * dhcp_smach_t *: pointer to interface DHCP state machine; 770 * output: B_TRUE if a client hostname was added; B_FALSE otherwise. 771 */ 772 773 boolean_t 774 dhcp_add_hostname_opt(dhcp_pkt_t *dpkt, dhcp_smach_t *dsmp) 775 { 776 const char *reqhost; 777 char nodename[MAXNAMELEN]; 778 779 if (!df_get_bool(dsmp->dsm_name, dsmp->dsm_isv6, DF_REQUEST_HOSTNAME)) 780 return (B_FALSE); 781 782 dhcpmsg(MSG_DEBUG, "dhcp_add_hostname_opt: DF_REQUEST_HOSTNAME"); 783 784 if (dsmp->dsm_msg_reqhost != NULL && 785 ipadm_is_valid_hostname(dsmp->dsm_msg_reqhost)) { 786 reqhost = dsmp->dsm_msg_reqhost; 787 } else { 788 char hostfile[PATH_MAX + 1]; 789 790 (void) snprintf(hostfile, sizeof (hostfile), 791 "/etc/hostname.%s", dsmp->dsm_name); 792 reqhost = iffile_to_hostname(hostfile); 793 } 794 795 if (reqhost == NULL && (dsmp->dsm_dflags & DHCP_IF_PRIMARY) && 796 dhcp_get_nodename(nodename, sizeof (nodename))) { 797 reqhost = nodename; 798 } 799 800 if (reqhost != NULL) { 801 free(dsmp->dsm_reqhost); 802 if ((dsmp->dsm_reqhost = strdup(reqhost)) == NULL) 803 dhcpmsg(MSG_WARNING, "dhcp_add_hostname_opt: cannot" 804 " allocate memory for host name option"); 805 } 806 807 if (dsmp->dsm_reqhost != NULL) { 808 dhcpmsg(MSG_DEBUG, "dhcp_add_hostname_opt: host %s for %s", 809 dsmp->dsm_reqhost, dsmp->dsm_name); 810 (void) add_pkt_opt(dpkt, CD_HOSTNAME, dsmp->dsm_reqhost, 811 strlen(dsmp->dsm_reqhost)); 812 return (B_FALSE); 813 } else { 814 dhcpmsg(MSG_DEBUG, "dhcp_add_hostname_opt: no hostname for %s", 815 dsmp->dsm_name); 816 } 817 818 return (B_TRUE); 819 } 820 821 /* 822 * dhcp_add_fqdn_opt(): Set client FQDN option if dhcp_assemble_fqdn() 823 * initializes an FQDN, or else do nothing. 824 * 825 * input: dhcp_pkt_t *: pointer to DHCP message being constructed; 826 * dhcp_smach_t *: pointer to interface DHCP state machine; 827 * output: B_TRUE if a client FQDN was added; B_FALSE otherwise. 828 */ 829 830 boolean_t 831 dhcp_add_fqdn_opt(dhcp_pkt_t *dpkt, dhcp_smach_t *dsmp) 832 { 833 /* 834 * RFC 4702 section 2: 835 * 836 * The format of the Client FQDN option is: 837 * 838 * Code Len Flags RCODE1 RCODE2 Domain Name 839 * +------+------+------+------+------+------+-- 840 * | 81 | n | | | | ... 841 * +------+------+------+------+------+------+-- 842 * 843 * Code and Len are distinct, and the remainder is in a single buffer, 844 * opt81, for Flags + (unused) RCODE1 and RCODE2 (all octets) and a 845 * potentially maximum-length domain name. 846 * 847 * The format of the Flags field is: 848 * 849 * 0 1 2 3 4 5 6 7 850 * +-+-+-+-+-+-+-+-+ 851 * | MBZ |N|E|O|S| 852 * +-+-+-+-+-+-+-+-+ 853 * 854 * where MBZ is ignored and NEOS are: 855 * 856 * S = 1 to request that "the server SHOULD perform the A RR (FQDN-to- 857 * address) DNS updates; 858 * 859 * O = 0, for a server-only response bit; 860 * 861 * E = 1 to indicate the domain name is in "canonical wire format, 862 * without compression (i.e., ns_name_pton2) .... This encoding SHOULD 863 * be used by clients ...."; 864 * 865 * N = 0 to request that "the server SHALL perform DNS updates [of the 866 * PTR RR]." (1 would request SHALL NOT update). 867 */ 868 869 const uint8_t S_BIT_POS = 7; 870 const uint8_t E_BIT_POS = 5; 871 const uint8_t S_BIT = 1 << (7 - S_BIT_POS); 872 const uint8_t E_BIT = 1 << (7 - E_BIT_POS); 873 const size_t OPT_FQDN_METALEN = 3; 874 char fqdnbuf[MAXNAMELEN]; 875 uchar_t enc_fqdnbuf[MAXNAMELEN]; 876 uint8_t fqdnopt[MAXNAMELEN + OPT_FQDN_METALEN]; 877 uint_t fqdncode; 878 size_t len, metalen; 879 880 if (dsmp->dsm_isv6) 881 return (B_FALSE); 882 883 if (!dhcp_assemble_fqdn(fqdnbuf, sizeof (fqdnbuf), dsmp)) 884 return (B_FALSE); 885 886 /* encode the FQDN in canonical wire format */ 887 888 if (ns_name_pton2(fqdnbuf, enc_fqdnbuf, sizeof (enc_fqdnbuf), 889 &len) < 0) { 890 dhcpmsg(MSG_WARNING, "dhcp_add_fqdn_opt: error encoding domain" 891 " name %s", fqdnbuf); 892 return (B_FALSE); 893 } 894 895 dhcpmsg(MSG_DEBUG, "dhcp_add_fqdn_opt: interface FQDN is %s" 896 " for %s", fqdnbuf, dsmp->dsm_name); 897 898 bzero(fqdnopt, sizeof (fqdnopt)); 899 fqdncode = CD_CLIENTFQDN; 900 metalen = OPT_FQDN_METALEN; 901 *fqdnopt = S_BIT | E_BIT; 902 (void) memcpy(fqdnopt + metalen, enc_fqdnbuf, len); 903 (void) add_pkt_opt(dpkt, fqdncode, fqdnopt, metalen + len); 904 905 return (B_TRUE); 906 } 907 908 /* 909 * dhcp_adopt_domainname(): Set namebuf if either dsm_dhcp_domainname or 910 * resolv's "default domain (deprecated)" is defined. 911 * 912 * input: char *: pointer to buffer to which domain name will be written; 913 * size_t length of buffer; 914 * dhcp_smach_t *: pointer to interface DHCP state machine; 915 * output: B_TRUE if namebuf was set to a valid domain name; B_FALSE 916 * otherwise. 917 */ 918 919 static boolean_t 920 dhcp_adopt_domainname(char *namebuf, size_t buflen, dhcp_smach_t *dsmp) 921 { 922 const char *domainname; 923 struct __res_state res_state; 924 int lasterrno; 925 926 domainname = dsmp->dsm_dhcp_domainname; 927 928 if (ipadm_is_nil_hostname(domainname)) { 929 /* 930 * fall back to resolv's "default domain (deprecated)" 931 */ 932 bzero(&res_state, sizeof (struct __res_state)); 933 934 if ((lasterrno = res_ninit(&res_state)) != 0) { 935 dhcpmsg(MSG_WARNING, "dhcp_adopt_domainname: error %d" 936 " initializing resolver", lasterrno); 937 return (B_FALSE); 938 } 939 940 domainname = NULL; 941 if (!ipadm_is_nil_hostname(res_state.defdname)) 942 domainname = res_state.defdname; 943 944 /* N.b. res_state.defdname survives the following call */ 945 res_ndestroy(&res_state); 946 } 947 948 if (domainname == NULL) 949 return (B_FALSE); 950 951 if (strlcpy(namebuf, domainname, buflen) >= buflen) { 952 dhcpmsg(MSG_WARNING, 953 "dhcp_adopt_domainname: too long adopted domain" 954 " name %s for %s", domainname, dsmp->dsm_name); 955 return (B_FALSE); 956 } 957 958 return (B_TRUE); 959 } 960 961 /* 962 * dhcp_pick_domainname(): Set namebuf if DNS_DOMAINNAME is defined in 963 * /etc/default/dhcpagent or if dhcp_adopt_domainname() 964 * succeeds. 965 * 966 * input: char *: pointer to buffer to which domain name will be written; 967 * size_t length of buffer; 968 * dhcp_smach_t *: pointer to interface DHCP state machine; 969 * output: B_TRUE if namebuf was set to a valid domain name; B_FALSE 970 * otherwise. 971 */ 972 973 static boolean_t 974 dhcp_pick_domainname(char *namebuf, size_t buflen, dhcp_smach_t *dsmp) 975 { 976 const char *domainname; 977 978 /* 979 * Try to use a static DNS_DOMAINNAME if defined in 980 * /etc/default/dhcpagent. 981 */ 982 domainname = df_get_string(dsmp->dsm_name, dsmp->dsm_isv6, 983 DF_DNS_DOMAINNAME); 984 if (!ipadm_is_nil_hostname(domainname)) { 985 if (strlcpy(namebuf, domainname, buflen) >= buflen) { 986 dhcpmsg(MSG_WARNING, "dhcp_pick_domainname: too long" 987 " DNS_DOMAINNAME %s for %s", domainname, 988 dsmp->dsm_name); 989 return (B_FALSE); 990 } 991 return (B_TRUE); 992 } else if (df_get_bool(dsmp->dsm_name, dsmp->dsm_isv6, 993 DF_ADOPT_DOMAINNAME)) { 994 return (dhcp_adopt_domainname(namebuf, buflen, dsmp)); 995 } else { 996 return (B_FALSE); 997 } 998 } 999 1000 /* 1001 * dhcp_assemble_fqdn(): Set fqdnbuf if REQUEST_FQDN is set and 1002 * either a host name was sent in the IPC message (e.g., 1003 * from ipadm(1M) -h,--reqhost) or the interface is 1004 * primary and a nodename(4) is defined. If the host 1005 * name is not already fully qualified per is_fqdn(), 1006 * then dhcp_pick_domainname() is tried to select a 1007 * domain to be used to construct an FQDN. 1008 * 1009 * input: char *: pointer to buffer to which FQDN will be written; 1010 * size_t length of buffer; 1011 * dhcp_smach_t *: pointer to interface DHCP state machine; 1012 * output: B_TRUE if fqdnbuf was assigned a valid FQDN; B_FALSE otherwise. 1013 */ 1014 1015 static boolean_t 1016 dhcp_assemble_fqdn(char *fqdnbuf, size_t buflen, dhcp_smach_t *dsmp) 1017 { 1018 char nodename[MAXNAMELEN], *reqhost; 1019 size_t pos, len; 1020 1021 1022 if (!df_get_bool(dsmp->dsm_name, dsmp->dsm_isv6, DF_REQUEST_FQDN)) 1023 return (B_FALSE); 1024 1025 dhcpmsg(MSG_DEBUG, "dhcp_assemble_fqdn: DF_REQUEST_FQDN"); 1026 1027 /* It's convenient to ensure fqdnbuf is always null-terminated */ 1028 bzero(fqdnbuf, buflen); 1029 1030 reqhost = dsmp->dsm_msg_reqhost; 1031 if (ipadm_is_nil_hostname(reqhost) && 1032 (dsmp->dsm_dflags & DHCP_IF_PRIMARY) && 1033 dhcp_get_nodename(nodename, sizeof (nodename))) { 1034 reqhost = nodename; 1035 } 1036 1037 if (ipadm_is_nil_hostname(reqhost)) { 1038 dhcpmsg(MSG_DEBUG, 1039 "dhcp_assemble_fqdn: no interface reqhost for %s", 1040 dsmp->dsm_name); 1041 return (B_FALSE); 1042 } 1043 1044 if ((pos = strlcpy(fqdnbuf, reqhost, buflen)) >= buflen) { 1045 dhcpmsg(MSG_WARNING, "dhcp_assemble_fqdn: too long reqhost %s" 1046 " for %s", reqhost, dsmp->dsm_name); 1047 return (B_FALSE); 1048 } 1049 1050 /* 1051 * If not yet FQDN, construct if possible 1052 */ 1053 if (!is_fqdn(reqhost)) { 1054 char domainname[MAXNAMELEN]; 1055 size_t needdots; 1056 1057 if (!dhcp_pick_domainname(domainname, sizeof (domainname), 1058 dsmp)) { 1059 dhcpmsg(MSG_DEBUG, 1060 "dhcp_assemble_fqdn: no domain name for %s", 1061 dsmp->dsm_name); 1062 return (B_FALSE); 1063 } 1064 1065 /* 1066 * Finish constructing FQDN. Account for space needed to hold a 1067 * separator '.' and a terminating '.'. 1068 */ 1069 len = strlen(domainname); 1070 needdots = 1 + (domainname[len - 1] != '.'); 1071 1072 if (pos + len + needdots >= buflen) { 1073 dhcpmsg(MSG_WARNING, "dhcp_assemble_fqdn: too long" 1074 " FQDN %s.%s for %s", fqdnbuf, domainname, 1075 dsmp->dsm_name); 1076 return (B_FALSE); 1077 } 1078 1079 /* add separator and then domain name */ 1080 fqdnbuf[pos++] = '.'; 1081 if (strlcpy(fqdnbuf + pos, domainname, buflen - pos) >= 1082 buflen - pos) { 1083 /* shouldn't get here as we checked above */ 1084 return (B_FALSE); 1085 } 1086 pos += len; 1087 1088 /* ensure the final character is '.' */ 1089 if (needdots > 1) 1090 fqdnbuf[pos++] = '.'; /* following is already zeroed */ 1091 } 1092 1093 if (!ipadm_is_valid_hostname(fqdnbuf)) { 1094 dhcpmsg(MSG_WARNING, "dhcp_assemble_fqdn: invalid FQDN %s" 1095 " for %s", fqdnbuf, dsmp->dsm_name); 1096 return (B_FALSE); 1097 } 1098 1099 return (B_TRUE); 1100 } 1101 1102 /* 1103 * is_fqdn() : Determine if the `hostname' can be considered as a Fully 1104 * Qualified Domain Name by being "rooted" (i.e., ending in '.') 1105 * or by containing at least three DNS labels (e.g., 1106 * srv.example.com). 1107 * 1108 * input: const char *: the hostname to inspect; 1109 * output: boolean_t: B_TRUE if `hostname' is not NULL satisfies the 1110 * criteria above; otherwise, B_FALSE; 1111 */ 1112 1113 boolean_t 1114 is_fqdn(const char *hostname) 1115 { 1116 const char *c; 1117 size_t i; 1118 1119 if (hostname == NULL) 1120 return (B_FALSE); 1121 1122 i = strlen(hostname); 1123 if (i > 0 && hostname[i - 1] == '.') 1124 return (B_TRUE); 1125 1126 c = hostname; 1127 i = 0; 1128 while ((c = strchr(c, '.')) != NULL) { 1129 ++i; 1130 ++c; 1131 } 1132 1133 /* at least two separators is inferred to be fully-qualified */ 1134 return (i >= 2); 1135 } 1136 1137 /* 1138 * terminate_at_space(): Reset the first space, 0x20, to 0x0 in the 1139 * specified string. 1140 * 1141 * input: char *: NULL or a null-terminated string; 1142 * output: void. 1143 */ 1144 1145 static void 1146 terminate_at_space(char *value) 1147 { 1148 if (value != NULL) { 1149 char *sp; 1150 1151 sp = strchr(value, ' '); 1152 if (sp != NULL) 1153 *sp = '\0'; 1154 } 1155 } 1156 1157 /* 1158 * get_offered_domainname_v4(): decode a defined v4 DNSdmain value if it 1159 * exists to return a copy of the domain 1160 * name. 1161 * 1162 * input: dhcp_smach_t *: the state machine REQUESTs are being sent from; 1163 * PKT_LIST *: the best packet to be used to construct a REQUEST; 1164 * output: char *: NULL or a copy of the domain name ('\0' terminated); 1165 */ 1166 1167 static char * 1168 get_offered_domainname_v4(PKT_LIST *offer) 1169 { 1170 char *domainname = NULL; 1171 DHCP_OPT *opt; 1172 1173 if ((opt = offer->opts[CD_DNSDOMAIN]) != NULL) { 1174 uchar_t *valptr; 1175 dhcp_symbol_t *symp; 1176 1177 valptr = (uchar_t *)opt + DHCP_OPT_META_LEN; 1178 1179 symp = inittab_getbycode( 1180 ITAB_CAT_STANDARD, ITAB_CONS_INFO, opt->code); 1181 if (symp != NULL) { 1182 domainname = inittab_decode(symp, valptr, 1183 opt->len, B_TRUE); 1184 terminate_at_space(domainname); 1185 free(symp); 1186 } 1187 } 1188 1189 return (domainname); 1190 } 1191 1192 /* 1193 * save_domainname(): assign dsm_dhcp_domainname from 1194 * get_offered_domainname_v4 or leave the field NULL if no 1195 * option is present. 1196 * 1197 * input: dhcp_smach_t *: the state machine REQUESTs are being sent from; 1198 * PKT_LIST *: the best packet to be used to construct a REQUEST; 1199 * output: void 1200 */ 1201 1202 void 1203 save_domainname(dhcp_smach_t *dsmp, PKT_LIST *offer) 1204 { 1205 char *domainname = NULL; 1206 1207 free(dsmp->dsm_dhcp_domainname); 1208 dsmp->dsm_dhcp_domainname = NULL; 1209 1210 if (!dsmp->dsm_isv6) { 1211 domainname = get_offered_domainname_v4(offer); 1212 } 1213 1214 dsmp->dsm_dhcp_domainname = domainname; 1215 } 1216