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 */ 24 25 #include <sys/types.h> 26 #include <stdlib.h> 27 #include <assert.h> 28 #include <errno.h> 29 #include <locale.h> 30 #include <string.h> 31 #include <unistd.h> 32 #include <signal.h> 33 #include <stdio.h> 34 #include <stdio_ext.h> 35 #include <dhcp_hostconf.h> 36 #include <dhcpagent_ipc.h> 37 #include <dhcpagent_util.h> 38 #include <dhcpmsg.h> 39 #include <netinet/dhcp.h> 40 #include <net/route.h> 41 #include <sys/sockio.h> 42 #include <sys/stat.h> 43 #include <stropts.h> 44 #include <fcntl.h> 45 #include <sys/scsi/adapters/iscsi_if.h> 46 47 #include "async.h" 48 #include "agent.h" 49 #include "script_handler.h" 50 #include "util.h" 51 #include "class_id.h" 52 #include "states.h" 53 #include "packet.h" 54 #include "interface.h" 55 #include "defaults.h" 56 57 #ifndef TEXT_DOMAIN 58 #define TEXT_DOMAIN "SYS_TEST" 59 #endif 60 61 iu_timer_id_t inactivity_id; 62 int class_id_len = 0; 63 char *class_id; 64 iu_eh_t *eh; 65 iu_tq_t *tq; 66 pid_t grandparent; 67 int rtsock_fd; 68 69 static boolean_t shutdown_started = B_FALSE; 70 static boolean_t do_adopt = B_FALSE; 71 static unsigned int debug_level = 0; 72 static iu_eh_callback_t accept_event, ipc_event, rtsock_event; 73 74 /* 75 * The ipc_cmd_allowed[] table indicates which IPC commands are allowed in 76 * which states; a non-zero value indicates the command is permitted. 77 * 78 * START is permitted if the state machine is fresh, or if we are in the 79 * process of trying to obtain a lease (as a convenience to save the 80 * administrator from having to do an explicit DROP). EXTEND, RELEASE, and 81 * GET_TAG require a lease to be obtained in order to make sense. INFORM is 82 * permitted if the interface is fresh or has an INFORM in progress or 83 * previously done on it -- otherwise a DROP or RELEASE is first required. 84 * PING and STATUS always make sense and thus are always permitted, as is DROP 85 * in order to permit the administrator to always bail out. 86 */ 87 static int ipc_cmd_allowed[DHCP_NSTATES][DHCP_NIPC] = { 88 /* D E P R S S I G */ 89 /* R X I E T T N E */ 90 /* O T N L A A F T */ 91 /* P E G E R T O _ */ 92 /* . N . A T U R T */ 93 /* . D . S . S M A */ 94 /* . . . E . . . G */ 95 /* INIT */ { 1, 0, 1, 0, 1, 1, 1, 0 }, 96 /* SELECTING */ { 1, 0, 1, 0, 1, 1, 0, 0 }, 97 /* REQUESTING */ { 1, 0, 1, 0, 1, 1, 0, 0 }, 98 /* PRE_BOUND */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 99 /* BOUND */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 100 /* RENEWING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 101 /* REBINDING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 102 /* INFORMATION */ { 1, 0, 1, 0, 1, 1, 1, 1 }, 103 /* INIT_REBOOT */ { 1, 0, 1, 1, 1, 1, 0, 0 }, 104 /* ADOPTING */ { 1, 0, 1, 1, 0, 1, 0, 0 }, 105 /* INFORM_SENT */ { 1, 0, 1, 0, 1, 1, 1, 0 }, 106 /* DECLINING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 107 /* RELEASING */ { 1, 0, 1, 0, 0, 1, 0, 1 }, 108 }; 109 110 #define CMD_ISPRIV 0x1 /* Command requires privileges */ 111 #define CMD_CREATE 0x2 /* Command creates an interface */ 112 #define CMD_BOOTP 0x4 /* Command is valid with BOOTP */ 113 #define CMD_IMMED 0x8 /* Reply is immediate (no BUSY state) */ 114 115 static uint_t ipc_cmd_flags[DHCP_NIPC] = { 116 /* DHCP_DROP */ CMD_ISPRIV|CMD_BOOTP, 117 /* DHCP_EXTEND */ CMD_ISPRIV, 118 /* DHCP_PING */ CMD_BOOTP|CMD_IMMED, 119 /* DHCP_RELEASE */ CMD_ISPRIV, 120 /* DHCP_START */ CMD_CREATE|CMD_ISPRIV|CMD_BOOTP, 121 /* DHCP_STATUS */ CMD_BOOTP|CMD_IMMED, 122 /* DHCP_INFORM */ CMD_CREATE|CMD_ISPRIV, 123 /* DHCP_GET_TAG */ CMD_BOOTP|CMD_IMMED 124 }; 125 126 static boolean_t is_iscsi_active(void); 127 128 int 129 main(int argc, char **argv) 130 { 131 boolean_t is_daemon = B_TRUE; 132 boolean_t is_verbose; 133 int ipc_fd; 134 int c; 135 int aware = RTAW_UNDER_IPMP; 136 struct rlimit rl; 137 138 debug_level = df_get_int("", B_FALSE, DF_DEBUG_LEVEL); 139 is_verbose = df_get_bool("", B_FALSE, DF_VERBOSE); 140 141 /* 142 * -l is ignored for compatibility with old agent. 143 */ 144 145 while ((c = getopt(argc, argv, "vd:l:fa")) != EOF) { 146 147 switch (c) { 148 149 case 'a': 150 do_adopt = B_TRUE; 151 grandparent = getpid(); 152 break; 153 154 case 'd': 155 debug_level = strtoul(optarg, NULL, 0); 156 break; 157 158 case 'f': 159 is_daemon = B_FALSE; 160 break; 161 162 case 'v': 163 is_verbose = B_TRUE; 164 break; 165 166 case '?': 167 (void) fprintf(stderr, "usage: %s [-a] [-d n] [-f] [-v]" 168 "\n", argv[0]); 169 return (EXIT_FAILURE); 170 171 default: 172 break; 173 } 174 } 175 176 (void) setlocale(LC_ALL, ""); 177 (void) textdomain(TEXT_DOMAIN); 178 179 if (geteuid() != 0) { 180 dhcpmsg_init(argv[0], B_FALSE, is_verbose, debug_level); 181 dhcpmsg(MSG_ERROR, "must be super-user"); 182 dhcpmsg_fini(); 183 return (EXIT_FAILURE); 184 } 185 186 if (is_daemon && daemonize() == 0) { 187 dhcpmsg_init(argv[0], B_FALSE, is_verbose, debug_level); 188 dhcpmsg(MSG_ERR, "cannot become daemon, exiting"); 189 dhcpmsg_fini(); 190 return (EXIT_FAILURE); 191 } 192 193 /* 194 * Seed the random number generator, since we're going to need it 195 * to set transaction id's and for exponential backoff. 196 */ 197 srand48(gethrtime() ^ gethostid() ^ getpid()); 198 199 dhcpmsg_init(argv[0], is_daemon, is_verbose, debug_level); 200 (void) atexit(dhcpmsg_fini); 201 202 tq = iu_tq_create(); 203 eh = iu_eh_create(); 204 205 if (eh == NULL || tq == NULL) { 206 errno = ENOMEM; 207 dhcpmsg(MSG_ERR, "cannot create timer queue or event handler"); 208 return (EXIT_FAILURE); 209 } 210 211 /* 212 * ignore most signals that could be reasonably generated. 213 */ 214 215 (void) signal(SIGTERM, graceful_shutdown); 216 (void) signal(SIGQUIT, graceful_shutdown); 217 (void) signal(SIGPIPE, SIG_IGN); 218 (void) signal(SIGUSR1, SIG_IGN); 219 (void) signal(SIGUSR2, SIG_IGN); 220 (void) signal(SIGINT, SIG_IGN); 221 (void) signal(SIGHUP, SIG_IGN); 222 (void) signal(SIGCHLD, SIG_IGN); 223 224 /* 225 * upon SIGTHAW we need to refresh any non-infinite leases. 226 */ 227 228 (void) iu_eh_register_signal(eh, SIGTHAW, refresh_smachs, NULL); 229 230 class_id = get_class_id(); 231 if (class_id != NULL) 232 class_id_len = strlen(class_id); 233 else 234 dhcpmsg(MSG_WARNING, "get_class_id failed, continuing " 235 "with no vendor class id"); 236 237 /* 238 * the inactivity timer is enabled any time there are no 239 * interfaces under DHCP control. if DHCP_INACTIVITY_WAIT 240 * seconds transpire without an interface under DHCP control, 241 * the agent shuts down. 242 */ 243 244 inactivity_id = iu_schedule_timer(tq, DHCP_INACTIVITY_WAIT, 245 inactivity_shutdown, NULL); 246 247 /* 248 * max out the number available descriptors, just in case.. 249 */ 250 251 rl.rlim_cur = RLIM_INFINITY; 252 rl.rlim_max = RLIM_INFINITY; 253 if (setrlimit(RLIMIT_NOFILE, &rl) == -1) 254 dhcpmsg(MSG_ERR, "setrlimit failed"); 255 256 (void) enable_extended_FILE_stdio(-1, -1); 257 258 /* 259 * Create and bind default IP sockets used to control interfaces and to 260 * catch stray packets. 261 */ 262 263 if (!dhcp_ip_default()) 264 return (EXIT_FAILURE); 265 266 /* 267 * create the ipc channel that the agent will listen for 268 * requests on, and register it with the event handler so that 269 * `accept_event' will be called back. 270 */ 271 272 switch (dhcp_ipc_init(&ipc_fd)) { 273 274 case 0: 275 break; 276 277 case DHCP_IPC_E_BIND: 278 dhcpmsg(MSG_ERROR, "dhcp_ipc_init: cannot bind to port " 279 "%i (agent already running?)", IPPORT_DHCPAGENT); 280 return (EXIT_FAILURE); 281 282 default: 283 dhcpmsg(MSG_ERROR, "dhcp_ipc_init failed"); 284 return (EXIT_FAILURE); 285 } 286 287 if (iu_register_event(eh, ipc_fd, POLLIN, accept_event, 0) == -1) { 288 dhcpmsg(MSG_ERR, "cannot register ipc fd for messages"); 289 return (EXIT_FAILURE); 290 } 291 292 /* 293 * Create the global routing socket. This is used for monitoring 294 * interface transitions, so that we learn about the kernel's Duplicate 295 * Address Detection status, and for inserting and removing default 296 * routes as learned from DHCP servers. Both v4 and v6 are handed 297 * with this one socket. 298 */ 299 rtsock_fd = socket(PF_ROUTE, SOCK_RAW, 0); 300 if (rtsock_fd == -1) { 301 dhcpmsg(MSG_ERR, "cannot open routing socket"); 302 return (EXIT_FAILURE); 303 } 304 305 /* 306 * We're IPMP-aware and can manage IPMP test addresses, so issue 307 * RT_AWARE to get routing socket messages for interfaces under IPMP. 308 */ 309 if (setsockopt(rtsock_fd, SOL_ROUTE, RT_AWARE, &aware, 310 sizeof (aware)) == -1) { 311 dhcpmsg(MSG_ERR, "cannot set RT_AWARE on routing socket"); 312 return (EXIT_FAILURE); 313 } 314 315 if (iu_register_event(eh, rtsock_fd, POLLIN, rtsock_event, 0) == -1) { 316 dhcpmsg(MSG_ERR, "cannot register routing socket for messages"); 317 return (EXIT_FAILURE); 318 } 319 320 /* 321 * if the -a (adopt) option was specified, try to adopt the 322 * kernel-managed interface before we start. 323 */ 324 325 if (do_adopt && !dhcp_adopt()) 326 return (EXIT_FAILURE); 327 328 /* 329 * For DHCPv6, we own all of the interfaces marked DHCPRUNNING. As 330 * we're starting operation here, if there are any of those interfaces 331 * lingering around, they're strays, and need to be removed. 332 * 333 * It might be nice to save these addresses off somewhere -- for both 334 * v4 and v6 -- and use them as hints for later negotiation. 335 */ 336 remove_v6_strays(); 337 338 /* 339 * enter the main event loop; this is where all the real work 340 * takes place (through registering events and scheduling timers). 341 * this function only returns when the agent is shutting down. 342 */ 343 344 switch (iu_handle_events(eh, tq)) { 345 346 case -1: 347 dhcpmsg(MSG_WARNING, "iu_handle_events exited abnormally"); 348 break; 349 350 case DHCP_REASON_INACTIVITY: 351 dhcpmsg(MSG_INFO, "no interfaces to manage, shutting down..."); 352 break; 353 354 case DHCP_REASON_TERMINATE: 355 dhcpmsg(MSG_INFO, "received SIGTERM, shutting down..."); 356 break; 357 358 case DHCP_REASON_SIGNAL: 359 dhcpmsg(MSG_WARNING, "received unexpected signal, shutting " 360 "down..."); 361 break; 362 } 363 364 (void) iu_eh_unregister_signal(eh, SIGTHAW, NULL); 365 366 iu_eh_destroy(eh); 367 iu_tq_destroy(tq); 368 369 return (EXIT_SUCCESS); 370 } 371 372 /* 373 * drain_script(): event loop callback during shutdown 374 * 375 * input: eh_t *: unused 376 * void *: unused 377 * output: boolean_t: B_TRUE if event loop should exit; B_FALSE otherwise 378 */ 379 380 /* ARGSUSED */ 381 boolean_t 382 drain_script(iu_eh_t *ehp, void *arg) 383 { 384 if (shutdown_started == B_FALSE) { 385 shutdown_started = B_TRUE; 386 /* 387 * Check if the system is diskless client and/or 388 * there are active iSCSI sessions 389 * 390 * Do not drop the lease, or the system will be 391 * unable to sync(dump) through nfs/iSCSI driver 392 */ 393 if (!do_adopt && !is_iscsi_active()) { 394 nuke_smach_list(); 395 } 396 } 397 return (script_count == 0); 398 } 399 400 /* 401 * accept_event(): accepts a new connection on the ipc socket and registers 402 * to receive its messages with the event handler 403 * 404 * input: iu_eh_t *: unused 405 * int: the file descriptor in the iu_eh_t * the connection came in on 406 * (other arguments unused) 407 * output: void 408 */ 409 410 /* ARGSUSED */ 411 static void 412 accept_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 413 { 414 int client_fd; 415 int is_priv; 416 417 if (dhcp_ipc_accept(fd, &client_fd, &is_priv) != 0) { 418 dhcpmsg(MSG_ERR, "accept_event: accept on ipc socket"); 419 return; 420 } 421 422 if (iu_register_event(eh, client_fd, POLLIN, ipc_event, 423 (void *)is_priv) == -1) { 424 dhcpmsg(MSG_ERROR, "accept_event: cannot register ipc socket " 425 "for callback"); 426 } 427 } 428 429 /* 430 * ipc_event(): processes incoming ipc requests 431 * 432 * input: iu_eh_t *: unused 433 * int: the file descriptor in the iu_eh_t * the request came in on 434 * short: unused 435 * iu_event_id_t: event ID 436 * void *: indicates whether the request is from a privileged client 437 * output: void 438 */ 439 440 /* ARGSUSED */ 441 static void 442 ipc_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 443 { 444 ipc_action_t ia, *iap; 445 dhcp_smach_t *dsmp; 446 int error, is_priv = (int)arg; 447 const char *ifname; 448 boolean_t isv6; 449 boolean_t dsm_created = B_FALSE; 450 451 ipc_action_init(&ia); 452 error = dhcp_ipc_recv_request(fd, &ia.ia_request, 453 DHCP_IPC_REQUEST_WAIT); 454 if (error != DHCP_IPC_SUCCESS) { 455 if (error != DHCP_IPC_E_EOF) { 456 dhcpmsg(MSG_ERROR, 457 "ipc_event: dhcp_ipc_recv_request failed: %s", 458 dhcp_ipc_strerror(error)); 459 } else { 460 dhcpmsg(MSG_DEBUG, "ipc_event: connection closed"); 461 } 462 if ((dsmp = lookup_smach_by_event(id)) != NULL) { 463 ipc_action_finish(dsmp, error); 464 } else { 465 (void) iu_unregister_event(eh, id, NULL); 466 (void) dhcp_ipc_close(fd); 467 } 468 return; 469 } 470 471 /* Fill in temporary ipc_action structure for utility functions */ 472 ia.ia_cmd = DHCP_IPC_CMD(ia.ia_request->message_type); 473 ia.ia_fd = fd; 474 ia.ia_eid = id; 475 476 if (ia.ia_cmd >= DHCP_NIPC) { 477 dhcpmsg(MSG_ERROR, 478 "ipc_event: invalid command (%s) attempted on %s", 479 dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname); 480 send_error_reply(&ia, DHCP_IPC_E_CMD_UNKNOWN); 481 return; 482 } 483 484 /* return EPERM for any of the privileged actions */ 485 486 if (!is_priv && (ipc_cmd_flags[ia.ia_cmd] & CMD_ISPRIV)) { 487 dhcpmsg(MSG_WARNING, 488 "ipc_event: privileged ipc command (%s) attempted on %s", 489 dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname); 490 send_error_reply(&ia, DHCP_IPC_E_PERM); 491 return; 492 } 493 494 /* 495 * Try to locate the state machine associated with this command. If 496 * the command is DHCP_START or DHCP_INFORM and there isn't a state 497 * machine already, make one (there may already be one from a previous 498 * failed attempt to START or INFORM). Otherwise, verify the reference 499 * is still valid. 500 * 501 * The interface name may be blank. In that case, we look up the 502 * primary interface, and the requested type (v4 or v6) doesn't matter. 503 */ 504 505 isv6 = (ia.ia_request->message_type & DHCP_V6) != 0; 506 ifname = ia.ia_request->ifname; 507 if (*ifname == '\0') 508 dsmp = primary_smach(isv6); 509 else 510 dsmp = lookup_smach(ifname, isv6); 511 512 if (dsmp != NULL) { 513 /* Note that verify_smach drops a reference */ 514 hold_smach(dsmp); 515 if (!verify_smach(dsmp)) 516 dsmp = NULL; 517 } 518 519 if (dsmp == NULL) { 520 /* 521 * If the user asked for the primary DHCP interface by giving 522 * an empty string and there is no primary, then check if we're 523 * handling dhcpinfo. If so, then simulate primary selection. 524 * Otherwise, report failure. 525 */ 526 if (ifname[0] == '\0') { 527 if (ia.ia_cmd == DHCP_GET_TAG) 528 dsmp = info_primary_smach(isv6); 529 if (dsmp == NULL) 530 error = DHCP_IPC_E_NOPRIMARY; 531 532 /* 533 * If there's no interface, and we're starting up, then create 534 * it now, along with a state machine for it. Note that if 535 * insert_smach fails, it discards the LIF reference. 536 */ 537 } else if (ipc_cmd_flags[ia.ia_cmd] & CMD_CREATE) { 538 dhcp_lif_t *lif; 539 540 lif = attach_lif(ifname, isv6, &error); 541 if (lif != NULL && 542 (dsmp = insert_smach(lif, &error)) != NULL) { 543 /* 544 * Get client ID for logical interface. (V4 545 * only, because V6 plumbs its own interfaces.) 546 */ 547 error = get_smach_cid(dsmp); 548 if (error != DHCP_IPC_SUCCESS) { 549 remove_smach(dsmp); 550 dsmp = NULL; 551 } 552 dsm_created = (dsmp != NULL); 553 } 554 555 /* 556 * Otherwise, this is an operation on an unknown interface. 557 */ 558 } else { 559 error = DHCP_IPC_E_UNKIF; 560 } 561 if (dsmp == NULL) { 562 send_error_reply(&ia, error); 563 return; 564 } 565 } 566 567 /* 568 * If this is a request for DHCP to manage a lease on an address, 569 * ensure that IFF_DHCPRUNNING is set (we don't set this when the lif 570 * is created because the lif may have been created for INFORM). 571 */ 572 if (ia.ia_cmd == DHCP_START && 573 (error = set_lif_dhcp(dsmp->dsm_lif)) != DHCP_IPC_SUCCESS) { 574 if (dsm_created) 575 remove_smach(dsmp); 576 send_error_reply(&ia, error); 577 return; 578 } 579 580 if ((dsmp->dsm_dflags & DHCP_IF_BOOTP) && 581 !(ipc_cmd_flags[ia.ia_cmd] & CMD_BOOTP)) { 582 dhcpmsg(MSG_ERROR, "command %s not valid for BOOTP on %s", 583 dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 584 send_error_reply(&ia, DHCP_IPC_E_BOOTP); 585 return; 586 } 587 588 /* 589 * verify that the state machine is in a state which will allow the 590 * command. we do this up front so that we can return an error 591 * *before* needlessly cancelling an in-progress transaction. 592 */ 593 594 if (!check_cmd_allowed(dsmp->dsm_state, ia.ia_cmd)) { 595 dhcpmsg(MSG_DEBUG, 596 "in state %s; not allowing %s command on %s", 597 dhcp_state_to_string(dsmp->dsm_state), 598 dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 599 send_error_reply(&ia, 600 ia.ia_cmd == DHCP_START && dsmp->dsm_state != INIT ? 601 DHCP_IPC_E_RUNNING : DHCP_IPC_E_OUTSTATE); 602 return; 603 } 604 605 dhcpmsg(MSG_DEBUG, "in state %s; allowing %s command on %s", 606 dhcp_state_to_string(dsmp->dsm_state), 607 dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 608 609 if ((ia.ia_request->message_type & DHCP_PRIMARY) && is_priv) 610 make_primary(dsmp); 611 612 /* 613 * The current design dictates that there can be only one outstanding 614 * transaction per state machine -- this simplifies the code 615 * considerably and also fits well with RFCs 2131 and 3315. It is 616 * worth classifying the different DHCP commands into synchronous 617 * (those which we will handle now and reply to immediately) and 618 * asynchronous (those which require transactions and will be completed 619 * at an indeterminate time in the future): 620 * 621 * DROP: removes the agent's management of a state machine. 622 * asynchronous as the script program may be invoked. 623 * 624 * PING: checks to see if the agent has a named state machine. 625 * synchronous, since no packets need to be sent 626 * to the DHCP server. 627 * 628 * STATUS: returns information about a state machine. 629 * synchronous, since no packets need to be sent 630 * to the DHCP server. 631 * 632 * RELEASE: releases the agent's management of a state machine 633 * and brings the associated interfaces down. asynchronous 634 * as the script program may be invoked. 635 * 636 * EXTEND: renews a lease. asynchronous, since the agent 637 * needs to wait for an ACK, etc. 638 * 639 * START: starts DHCP on a named state machine. asynchronous since 640 * the agent needs to wait for OFFERs, ACKs, etc. 641 * 642 * INFORM: obtains configuration parameters for the system using 643 * externally configured interface. asynchronous, since the 644 * agent needs to wait for an ACK. 645 * 646 * Notice that EXTEND, INFORM, START, DROP and RELEASE are 647 * asynchronous. Notice also that asynchronous commands may occur from 648 * within the agent -- for instance, the agent will need to do implicit 649 * EXTENDs to extend the lease. In order to make the code simpler, the 650 * following rules apply for asynchronous commands: 651 * 652 * There can only be one asynchronous command at a time per state 653 * machine. The current asynchronous command is managed by the async_* 654 * api: async_start(), async_finish(), and async_cancel(). 655 * async_start() starts management of a new asynchronous command on an 656 * state machine, which should only be done after async_cancel() to 657 * terminate a previous command. When the command is completed, 658 * async_finish() should be called. 659 * 660 * Asynchronous commands started by a user command have an associated 661 * ipc_action which provides the agent with information for how to get 662 * in touch with the user command when the action completes. These 663 * ipc_action records also have an associated timeout which may be 664 * infinite. ipc_action_start() should be called when starting an 665 * asynchronous command requested by a user, which sets up the timer 666 * and keeps track of the ipc information (file descriptor, request 667 * type). When the asynchronous command completes, ipc_action_finish() 668 * should be called to return a command status code to the user and 669 * close the ipc connection). If the command does not complete before 670 * the timer fires, ipc_action_timeout() is called which closes the ipc 671 * connection and returns DHCP_IPC_E_TIMEOUT to the user. Note that 672 * independent of ipc_action_timeout(), ipc_action_finish() should be 673 * called. 674 * 675 * on a case-by-case basis, here is what happens (per state machine): 676 * 677 * o When an asynchronous command is requested, then 678 * async_cancel() is called to terminate any non-user 679 * action in progress. If there's a user action running, 680 * the user command is sent DHCP_IPC_E_PEND. 681 * 682 * o otherwise, the the transaction is started with 683 * async_start(). if the transaction is on behalf 684 * of a user, ipc_action_start() is called to keep 685 * track of the ipc information and set up the 686 * ipc_action timer. 687 * 688 * o if the command completes normally and before a 689 * timeout fires, then async_finish() is called. 690 * if there was an associated ipc_action, 691 * ipc_action_finish() is called to complete it. 692 * 693 * o if the command fails before a timeout fires, then 694 * async_finish() is called, and the state machine is 695 * is returned to a known state based on the command. 696 * if there was an associated ipc_action, 697 * ipc_action_finish() is called to complete it. 698 * 699 * o if the ipc_action timer fires before command 700 * completion, then DHCP_IPC_E_TIMEOUT is returned to 701 * the user. however, the transaction continues to 702 * be carried out asynchronously. 703 */ 704 705 if (ipc_cmd_flags[ia.ia_cmd] & CMD_IMMED) { 706 /* 707 * Only immediate commands (ping, status, get_tag) need to 708 * worry about freeing ia through one of the reply functions 709 * before returning. 710 */ 711 iap = &ia; 712 } else { 713 /* 714 * if shutdown request has been received, send back an error. 715 */ 716 if (shutdown_started) { 717 send_error_reply(&ia, DHCP_IPC_E_OUTSTATE); 718 return; 719 } 720 721 if (dsmp->dsm_dflags & DHCP_IF_BUSY) { 722 send_error_reply(&ia, DHCP_IPC_E_PEND); 723 return; 724 } 725 726 if (!ipc_action_start(dsmp, &ia)) { 727 dhcpmsg(MSG_WARNING, "ipc_event: ipc_action_start " 728 "failed for %s", dsmp->dsm_name); 729 send_error_reply(&ia, DHCP_IPC_E_MEMORY); 730 return; 731 } 732 733 /* Action structure consumed by above function */ 734 iap = &dsmp->dsm_ia; 735 } 736 737 switch (iap->ia_cmd) { 738 739 case DHCP_DROP: 740 if (dsmp->dsm_droprelease) 741 break; 742 dsmp->dsm_droprelease = B_TRUE; 743 744 /* 745 * Ensure that a timer associated with the existing state 746 * doesn't pop while we're waiting for the script to complete. 747 * (If so, chaos can result -- e.g., a timer causes us to end 748 * up in dhcp_selecting() would start acquiring a new lease on 749 * dsmp while our DHCP_DROP dismantling is ongoing.) 750 */ 751 cancel_smach_timers(dsmp); 752 (void) script_start(dsmp, isv6 ? EVENT_DROP6 : EVENT_DROP, 753 dhcp_drop, NULL, NULL); 754 break; /* not an immediate function */ 755 756 case DHCP_EXTEND: 757 (void) dhcp_extending(dsmp); 758 break; 759 760 case DHCP_GET_TAG: { 761 dhcp_optnum_t optnum; 762 void *opt = NULL; 763 uint_t optlen; 764 boolean_t did_alloc = B_FALSE; 765 PKT_LIST *ack = dsmp->dsm_ack; 766 int i; 767 768 /* 769 * verify the request makes sense. 770 */ 771 772 if (iap->ia_request->data_type != DHCP_TYPE_OPTNUM || 773 iap->ia_request->data_length != sizeof (dhcp_optnum_t)) { 774 send_error_reply(iap, DHCP_IPC_E_PROTO); 775 break; 776 } 777 778 (void) memcpy(&optnum, iap->ia_request->buffer, 779 sizeof (dhcp_optnum_t)); 780 781 load_option: 782 switch (optnum.category) { 783 784 case DSYM_SITE: /* FALLTHRU */ 785 case DSYM_STANDARD: 786 for (i = 0; i < dsmp->dsm_pillen; i++) { 787 if (dsmp->dsm_pil[i] == optnum.code) 788 break; 789 } 790 if (i < dsmp->dsm_pillen) 791 break; 792 if (isv6) { 793 opt = dhcpv6_pkt_option(ack, NULL, optnum.code, 794 NULL); 795 } else { 796 if (optnum.code <= DHCP_LAST_OPT) 797 opt = ack->opts[optnum.code]; 798 } 799 break; 800 801 case DSYM_VENDOR: 802 if (isv6) { 803 dhcpv6_option_t *d6o; 804 uint32_t ent; 805 806 /* 807 * Look through vendor options to find our 808 * enterprise number. 809 */ 810 d6o = NULL; 811 for (;;) { 812 d6o = dhcpv6_pkt_option(ack, d6o, 813 DHCPV6_OPT_VENDOR_OPT, &optlen); 814 if (d6o == NULL) 815 break; 816 optlen -= sizeof (*d6o); 817 if (optlen < sizeof (ent)) 818 continue; 819 (void) memcpy(&ent, d6o + 1, 820 sizeof (ent)); 821 if (ntohl(ent) != DHCPV6_SUN_ENT) 822 continue; 823 break; 824 } 825 if (d6o != NULL) { 826 /* 827 * Now find the requested vendor option 828 * within the vendor options block. 829 */ 830 opt = dhcpv6_find_option( 831 (char *)(d6o + 1) + sizeof (ent), 832 optlen - sizeof (ent), NULL, 833 optnum.code, NULL); 834 } 835 } else { 836 /* 837 * the test against VS_OPTION_START is broken 838 * up into two tests to avoid compiler warnings 839 * under intel. 840 */ 841 if ((optnum.code > VS_OPTION_START || 842 optnum.code == VS_OPTION_START) && 843 optnum.code <= VS_OPTION_END) 844 opt = ack->vs[optnum.code]; 845 } 846 break; 847 848 case DSYM_FIELD: 849 if (isv6) { 850 dhcpv6_message_t *d6m = 851 (dhcpv6_message_t *)ack->pkt; 852 dhcpv6_option_t *d6o; 853 854 /* Validate the packet field the user wants */ 855 optlen = optnum.code + optnum.size; 856 if (d6m->d6m_msg_type == 857 DHCPV6_MSG_RELAY_FORW || 858 d6m->d6m_msg_type == 859 DHCPV6_MSG_RELAY_REPL) { 860 if (optlen > sizeof (dhcpv6_relay_t)) 861 break; 862 } else { 863 if (optlen > sizeof (*d6m)) 864 break; 865 } 866 867 opt = malloc(sizeof (*d6o) + optnum.size); 868 if (opt != NULL) { 869 d6o = opt; 870 d6o->d6o_code = htons(optnum.code); 871 d6o->d6o_len = htons(optnum.size); 872 (void) memcpy(d6o + 1, (caddr_t)d6m + 873 optnum.code, optnum.size); 874 } 875 } else { 876 if (optnum.code + optnum.size > sizeof (PKT)) 877 break; 878 879 /* 880 * + 2 to account for option code and length 881 * byte 882 */ 883 opt = malloc(optnum.size + 2); 884 if (opt != NULL) { 885 DHCP_OPT *v4opt = opt; 886 887 v4opt->len = optnum.size; 888 v4opt->code = optnum.code; 889 (void) memcpy(v4opt->value, 890 (caddr_t)ack->pkt + optnum.code, 891 optnum.size); 892 } 893 } 894 895 if (opt == NULL) { 896 send_error_reply(iap, DHCP_IPC_E_MEMORY); 897 return; 898 } 899 did_alloc = B_TRUE; 900 break; 901 902 default: 903 send_error_reply(iap, DHCP_IPC_E_PROTO); 904 return; 905 } 906 907 /* 908 * return the option payload, if there was one. the "+ 2" 909 * accounts for the option code number and length byte. 910 */ 911 912 if (opt != NULL) { 913 if (isv6) { 914 dhcpv6_option_t d6ov; 915 916 (void) memcpy(&d6ov, opt, sizeof (d6ov)); 917 optlen = ntohs(d6ov.d6o_len) + sizeof (d6ov); 918 } else { 919 optlen = ((DHCP_OPT *)opt)->len + 2; 920 } 921 send_data_reply(iap, 0, DHCP_TYPE_OPTION, opt, optlen); 922 923 if (did_alloc) 924 free(opt); 925 break; 926 } else if (ack != dsmp->dsm_orig_ack) { 927 /* 928 * There wasn't any definition for the option in the 929 * current ack, so now retry with the original ack if 930 * the original ack is not the current ack. 931 */ 932 ack = dsmp->dsm_orig_ack; 933 goto load_option; 934 } 935 936 /* 937 * note that an "okay" response is returned either in 938 * the case of an unknown option or a known option 939 * with no payload. this is okay (for now) since 940 * dhcpinfo checks whether an option is valid before 941 * ever performing ipc with the agent. 942 */ 943 944 send_ok_reply(iap); 945 break; 946 } 947 948 case DHCP_INFORM: 949 dhcp_inform(dsmp); 950 /* next destination: dhcp_acknak() */ 951 break; /* not an immediate function */ 952 953 case DHCP_PING: 954 if (dsmp->dsm_dflags & DHCP_IF_FAILED) 955 send_error_reply(iap, DHCP_IPC_E_FAILEDIF); 956 else 957 send_ok_reply(iap); 958 break; 959 960 case DHCP_RELEASE: 961 if (dsmp->dsm_droprelease) 962 break; 963 dsmp->dsm_droprelease = B_TRUE; 964 cancel_smach_timers(dsmp); /* see comment in DHCP_DROP above */ 965 (void) script_start(dsmp, isv6 ? EVENT_RELEASE6 : 966 EVENT_RELEASE, dhcp_release, "Finished with lease.", NULL); 967 break; /* not an immediate function */ 968 969 case DHCP_START: { 970 PKT_LIST *ack, *oack; 971 PKT_LIST *plp[2]; 972 973 deprecate_leases(dsmp); 974 975 /* 976 * if we have a valid hostconf lying around, then jump 977 * into INIT_REBOOT. if it fails, we'll end up going 978 * through the whole selecting() procedure again. 979 */ 980 981 error = read_hostconf(dsmp->dsm_name, plp, 2, dsmp->dsm_isv6); 982 ack = error > 0 ? plp[0] : NULL; 983 oack = error > 1 ? plp[1] : NULL; 984 985 /* 986 * If the allocation of the old ack fails, that's fine; 987 * continue without it. 988 */ 989 if (oack == NULL) 990 oack = ack; 991 992 /* 993 * As long as we've allocated something, start using it. 994 */ 995 if (ack != NULL) { 996 dsmp->dsm_orig_ack = oack; 997 dsmp->dsm_ack = ack; 998 dhcp_init_reboot(dsmp); 999 /* next destination: dhcp_acknak() */ 1000 break; 1001 } 1002 1003 /* 1004 * if not debugging, wait for a few seconds before 1005 * going into SELECTING. 1006 */ 1007 1008 if (debug_level == 0 && set_start_timer(dsmp)) { 1009 /* next destination: dhcp_start() */ 1010 break; 1011 } else { 1012 dhcp_selecting(dsmp); 1013 /* next destination: dhcp_requesting() */ 1014 break; 1015 } 1016 } 1017 1018 case DHCP_STATUS: { 1019 dhcp_status_t status; 1020 dhcp_lease_t *dlp; 1021 1022 status.if_began = monosec_to_time(dsmp->dsm_curstart_monosec); 1023 1024 /* 1025 * We return information on just the first lease as being 1026 * representative of the lot. A better status mechanism is 1027 * needed. 1028 */ 1029 dlp = dsmp->dsm_leases; 1030 1031 if (dlp == NULL || 1032 dlp->dl_lifs->lif_expire.dt_start == DHCP_PERM) { 1033 status.if_t1 = DHCP_PERM; 1034 status.if_t2 = DHCP_PERM; 1035 status.if_lease = DHCP_PERM; 1036 } else { 1037 status.if_t1 = status.if_began + 1038 dlp->dl_t1.dt_start; 1039 status.if_t2 = status.if_began + 1040 dlp->dl_t2.dt_start; 1041 status.if_lease = status.if_began + 1042 dlp->dl_lifs->lif_expire.dt_start; 1043 } 1044 1045 status.version = DHCP_STATUS_VER; 1046 status.if_state = dsmp->dsm_state; 1047 status.if_dflags = dsmp->dsm_dflags; 1048 status.if_sent = dsmp->dsm_sent; 1049 status.if_recv = dsmp->dsm_received; 1050 status.if_bad_offers = dsmp->dsm_bad_offers; 1051 1052 (void) strlcpy(status.if_name, dsmp->dsm_name, LIFNAMSIZ); 1053 1054 send_data_reply(iap, 0, DHCP_TYPE_STATUS, &status, 1055 sizeof (dhcp_status_t)); 1056 break; 1057 } 1058 } 1059 } 1060 1061 /* 1062 * check_rtm_addr(): determine if routing socket message matches interface 1063 * address 1064 * 1065 * input: const struct if_msghdr *: pointer to routing socket message 1066 * int: routing socket message length 1067 * boolean_t: set to B_TRUE if IPv6 1068 * const in6_addr_t *: pointer to IP address 1069 * output: boolean_t: B_TRUE if address is a match 1070 */ 1071 1072 static boolean_t 1073 check_rtm_addr(const struct ifa_msghdr *ifam, int msglen, boolean_t isv6, 1074 const in6_addr_t *addr) 1075 { 1076 const char *cp, *lim; 1077 uint_t flag; 1078 const struct sockaddr *sa; 1079 1080 if (!(ifam->ifam_addrs & RTA_IFA)) 1081 return (B_FALSE); 1082 1083 cp = (const char *)(ifam + 1); 1084 lim = (const char *)ifam + msglen; 1085 for (flag = 1; flag < RTA_IFA; flag <<= 1) { 1086 if (ifam->ifam_addrs & flag) { 1087 /* LINTED: alignment */ 1088 sa = (const struct sockaddr *)cp; 1089 if ((const char *)(sa + 1) > lim) 1090 return (B_FALSE); 1091 switch (sa->sa_family) { 1092 case AF_INET: 1093 cp += sizeof (struct sockaddr_in); 1094 break; 1095 case AF_LINK: 1096 cp += sizeof (struct sockaddr_dl); 1097 break; 1098 case AF_INET6: 1099 cp += sizeof (struct sockaddr_in6); 1100 break; 1101 default: 1102 cp += sizeof (struct sockaddr); 1103 break; 1104 } 1105 } 1106 } 1107 if (isv6) { 1108 const struct sockaddr_in6 *sin6; 1109 1110 /* LINTED: alignment */ 1111 sin6 = (const struct sockaddr_in6 *)cp; 1112 if ((const char *)(sin6 + 1) > lim) 1113 return (B_FALSE); 1114 if (sin6->sin6_family != AF_INET6) 1115 return (B_FALSE); 1116 return (IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, addr)); 1117 } else { 1118 const struct sockaddr_in *sinp; 1119 ipaddr_t v4addr; 1120 1121 /* LINTED: alignment */ 1122 sinp = (const struct sockaddr_in *)cp; 1123 if ((const char *)(sinp + 1) > lim) 1124 return (B_FALSE); 1125 if (sinp->sin_family != AF_INET) 1126 return (B_FALSE); 1127 IN6_V4MAPPED_TO_IPADDR(addr, v4addr); 1128 return (sinp->sin_addr.s_addr == v4addr); 1129 } 1130 } 1131 1132 /* 1133 * is_rtm_v6(): determine if routing socket message is IPv6 1134 * 1135 * input: struct ifa_msghdr *: pointer to routing socket message 1136 * int: message length 1137 * output: boolean_t 1138 */ 1139 1140 static boolean_t 1141 is_rtm_v6(const struct ifa_msghdr *ifam, int msglen) 1142 { 1143 const char *cp, *lim; 1144 uint_t flag; 1145 const struct sockaddr *sa; 1146 1147 cp = (const char *)(ifam + 1); 1148 lim = (const char *)ifam + msglen; 1149 for (flag = ifam->ifam_addrs; flag != 0; flag &= flag - 1) { 1150 /* LINTED: alignment */ 1151 sa = (const struct sockaddr *)cp; 1152 if ((const char *)(sa + 1) > lim) 1153 return (B_FALSE); 1154 switch (sa->sa_family) { 1155 case AF_INET: 1156 return (B_FALSE); 1157 case AF_LINK: 1158 cp += sizeof (struct sockaddr_dl); 1159 break; 1160 case AF_INET6: 1161 return (B_TRUE); 1162 default: 1163 cp += sizeof (struct sockaddr); 1164 break; 1165 } 1166 } 1167 return (B_FALSE); 1168 } 1169 1170 /* 1171 * check_lif(): check the state of a given logical interface and its DHCP 1172 * lease. We've been told by the routing socket that the 1173 * corresponding ifIndex has changed. This may mean that DAD has 1174 * completed or failed. 1175 * 1176 * input: dhcp_lif_t *: pointer to the LIF 1177 * const struct ifa_msghdr *: routing socket message 1178 * int: size of routing socket message 1179 * output: boolean_t: B_TRUE if DAD has completed on this interface 1180 */ 1181 1182 static boolean_t 1183 check_lif(dhcp_lif_t *lif, const struct ifa_msghdr *ifam, int msglen) 1184 { 1185 boolean_t isv6, dad_wait, unplumb; 1186 int fd; 1187 struct lifreq lifr; 1188 1189 isv6 = lif->lif_pif->pif_isv6; 1190 fd = isv6 ? v6_sock_fd : v4_sock_fd; 1191 1192 /* 1193 * Get the real (64 bit) logical interface flags. Note that the 1194 * routing socket message has flags, but these are just the lower 32 1195 * bits. 1196 */ 1197 unplumb = B_FALSE; 1198 (void) memset(&lifr, 0, sizeof (lifr)); 1199 (void) strlcpy(lifr.lifr_name, lif->lif_name, sizeof (lifr.lifr_name)); 1200 if (ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1) { 1201 /* 1202 * Failing to retrieve flags means that the interface is gone. 1203 * It hasn't failed to verify with DAD, but we still have to 1204 * give up on it. 1205 */ 1206 lifr.lifr_flags = 0; 1207 if (errno == ENXIO) { 1208 lif->lif_plumbed = B_FALSE; 1209 dhcpmsg(MSG_INFO, "%s has been removed; abandoning", 1210 lif->lif_name); 1211 if (!isv6) 1212 discard_default_routes(lif->lif_smachs); 1213 } else { 1214 dhcpmsg(MSG_ERR, 1215 "unable to retrieve interface flags on %s", 1216 lif->lif_name); 1217 } 1218 unplumb = B_TRUE; 1219 } else if (!check_rtm_addr(ifam, msglen, isv6, &lif->lif_v6addr)) { 1220 /* 1221 * If the message is not about this logical interface, 1222 * then just ignore it. 1223 */ 1224 return (B_FALSE); 1225 } else if (lifr.lifr_flags & IFF_DUPLICATE) { 1226 dhcpmsg(MSG_ERROR, "interface %s has duplicate address", 1227 lif->lif_name); 1228 lif_mark_decline(lif, "duplicate address"); 1229 close_ip_lif(lif); 1230 (void) open_ip_lif(lif, INADDR_ANY, B_TRUE); 1231 } 1232 1233 dad_wait = lif->lif_dad_wait; 1234 if (dad_wait) { 1235 dhcpmsg(MSG_VERBOSE, "check_lif: %s has finished DAD", 1236 lif->lif_name); 1237 lif->lif_dad_wait = B_FALSE; 1238 } 1239 1240 if (unplumb) 1241 unplumb_lif(lif); 1242 1243 return (dad_wait); 1244 } 1245 1246 /* 1247 * check_main_lif(): check the state of a main logical interface for a state 1248 * machine. This is used only for DHCPv6. 1249 * 1250 * input: dhcp_smach_t *: pointer to the state machine 1251 * const struct ifa_msghdr *: routing socket message 1252 * int: size of routing socket message 1253 * output: boolean_t: B_TRUE if LIF is ok. 1254 */ 1255 1256 static boolean_t 1257 check_main_lif(dhcp_smach_t *dsmp, const struct ifa_msghdr *ifam, int msglen) 1258 { 1259 dhcp_lif_t *lif = dsmp->dsm_lif; 1260 struct lifreq lifr; 1261 1262 /* 1263 * Get the real (64 bit) logical interface flags. Note that the 1264 * routing socket message has flags, but these are just the lower 32 1265 * bits. 1266 */ 1267 (void) memset(&lifr, 0, sizeof (lifr)); 1268 (void) strlcpy(lifr.lifr_name, lif->lif_name, sizeof (lifr.lifr_name)); 1269 if (ioctl(v6_sock_fd, SIOCGLIFFLAGS, &lifr) == -1) { 1270 /* 1271 * Failing to retrieve flags means that the interface is gone. 1272 * Our state machine is now trash. 1273 */ 1274 if (errno == ENXIO) { 1275 dhcpmsg(MSG_INFO, "%s has been removed; abandoning", 1276 lif->lif_name); 1277 } else { 1278 dhcpmsg(MSG_ERR, 1279 "unable to retrieve interface flags on %s", 1280 lif->lif_name); 1281 } 1282 return (B_FALSE); 1283 } else if (!check_rtm_addr(ifam, msglen, B_TRUE, &lif->lif_v6addr)) { 1284 /* 1285 * If the message is not about this logical interface, 1286 * then just ignore it. 1287 */ 1288 return (B_TRUE); 1289 } else if (lifr.lifr_flags & IFF_DUPLICATE) { 1290 dhcpmsg(MSG_ERROR, "interface %s has duplicate address", 1291 lif->lif_name); 1292 return (B_FALSE); 1293 } else { 1294 return (B_TRUE); 1295 } 1296 } 1297 1298 /* 1299 * process_link_up_down(): check the state of a physical interface for up/down 1300 * transitions; must go through INIT_REBOOT state if 1301 * the link flaps. 1302 * 1303 * input: dhcp_pif_t *: pointer to the physical interface to check 1304 * const struct if_msghdr *: routing socket message 1305 * output: none 1306 */ 1307 1308 static void 1309 process_link_up_down(dhcp_pif_t *pif, const struct if_msghdr *ifm) 1310 { 1311 struct lifreq lifr; 1312 boolean_t isv6; 1313 int fd; 1314 1315 /* 1316 * If the message implies no change of flags, then we're done; no need 1317 * to check further. Note that if we have multiple state machines on a 1318 * single physical interface, this test keeps us from issuing an ioctl 1319 * for each one. 1320 */ 1321 if ((ifm->ifm_flags & IFF_RUNNING) && pif->pif_running || 1322 !(ifm->ifm_flags & IFF_RUNNING) && !pif->pif_running) 1323 return; 1324 1325 /* 1326 * We don't know what the real interface flags are, because the 1327 * if_index number is only 16 bits; we must go ask. 1328 */ 1329 isv6 = pif->pif_isv6; 1330 fd = isv6 ? v6_sock_fd : v4_sock_fd; 1331 (void) memset(&lifr, 0, sizeof (lifr)); 1332 (void) strlcpy(lifr.lifr_name, pif->pif_name, sizeof (lifr.lifr_name)); 1333 1334 if (ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1 || 1335 !(lifr.lifr_flags & IFF_RUNNING)) { 1336 /* 1337 * If we've lost the interface or it has gone down, then 1338 * nothing special to do; just turn off the running flag. 1339 */ 1340 pif_status(pif, B_FALSE); 1341 } else { 1342 /* 1343 * Interface has come back up: go through verification process. 1344 */ 1345 pif_status(pif, B_TRUE); 1346 } 1347 } 1348 1349 /* 1350 * rtsock_event(): fetches routing socket messages and updates internal 1351 * interface state based on those messages. 1352 * 1353 * input: iu_eh_t *: unused 1354 * int: the routing socket file descriptor 1355 * (other arguments unused) 1356 * output: void 1357 */ 1358 1359 /* ARGSUSED */ 1360 static void 1361 rtsock_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 1362 { 1363 dhcp_smach_t *dsmp, *dsmnext; 1364 union { 1365 struct ifa_msghdr ifam; 1366 struct if_msghdr ifm; 1367 char buf[1024]; 1368 } msg; 1369 uint16_t ifindex; 1370 int msglen; 1371 boolean_t isv6; 1372 1373 if ((msglen = read(fd, &msg, sizeof (msg))) <= 0) 1374 return; 1375 1376 /* Note that the routing socket interface index is just 16 bits */ 1377 if (msg.ifm.ifm_type == RTM_IFINFO) { 1378 ifindex = msg.ifm.ifm_index; 1379 isv6 = (msg.ifm.ifm_flags & IFF_IPV6) ? B_TRUE : B_FALSE; 1380 } else if (msg.ifam.ifam_type == RTM_DELADDR || 1381 msg.ifam.ifam_type == RTM_NEWADDR) { 1382 ifindex = msg.ifam.ifam_index; 1383 isv6 = is_rtm_v6(&msg.ifam, msglen); 1384 } else { 1385 return; 1386 } 1387 1388 for (dsmp = lookup_smach_by_uindex(ifindex, NULL, isv6); 1389 dsmp != NULL; dsmp = dsmnext) { 1390 DHCPSTATE oldstate; 1391 boolean_t lif_finished; 1392 boolean_t lease_removed; 1393 dhcp_lease_t *dlp, *dlnext; 1394 1395 /* 1396 * Note that script_start can call dhcp_drop directly, and 1397 * that will do release_smach. 1398 */ 1399 dsmnext = lookup_smach_by_uindex(ifindex, dsmp, isv6); 1400 oldstate = dsmp->dsm_state; 1401 1402 /* 1403 * Ignore state machines that are currently processing drop or 1404 * release; there is nothing more we can do for them. 1405 */ 1406 if (dsmp->dsm_droprelease) 1407 continue; 1408 1409 /* 1410 * Look for link up/down notifications. These occur on a 1411 * physical interface basis. 1412 */ 1413 if (msg.ifm.ifm_type == RTM_IFINFO) { 1414 process_link_up_down(dsmp->dsm_lif->lif_pif, &msg.ifm); 1415 continue; 1416 } 1417 1418 /* 1419 * Since we cannot trust the flags reported by the routing 1420 * socket (they're just 32 bits -- and thus never include 1421 * IFF_DUPLICATE), and we can't trust the ifindex (it's only 16 1422 * bits and also doesn't reflect the alias in use), we get 1423 * flags on all matching interfaces, and go by that. 1424 */ 1425 lif_finished = B_FALSE; 1426 lease_removed = B_FALSE; 1427 for (dlp = dsmp->dsm_leases; dlp != NULL; dlp = dlnext) { 1428 dhcp_lif_t *lif, *lifnext; 1429 uint_t nlifs = dlp->dl_nlifs; 1430 1431 dlnext = dlp->dl_next; 1432 for (lif = dlp->dl_lifs; lif != NULL && nlifs > 0; 1433 lif = lifnext, nlifs--) { 1434 lifnext = lif->lif_next; 1435 if (check_lif(lif, &msg.ifam, msglen)) { 1436 dsmp->dsm_lif_wait--; 1437 lif_finished = B_TRUE; 1438 } 1439 } 1440 if (dlp->dl_nlifs == 0) { 1441 remove_lease(dlp); 1442 lease_removed = B_TRUE; 1443 } 1444 } 1445 1446 if ((isv6 && !check_main_lif(dsmp, &msg.ifam, msglen)) || 1447 (!isv6 && !verify_lif(dsmp->dsm_lif))) { 1448 finished_smach(dsmp, DHCP_IPC_E_INVIF); 1449 continue; 1450 } 1451 1452 /* 1453 * Ignore this state machine if nothing interesting has 1454 * happened. 1455 */ 1456 if (!lif_finished && dsmp->dsm_lif_down == 0 && 1457 (dsmp->dsm_leases != NULL || !lease_removed)) 1458 continue; 1459 1460 /* 1461 * If we're still waiting for DAD to complete on some of the 1462 * configured LIFs, then don't send a response. 1463 */ 1464 if (dsmp->dsm_lif_wait != 0) { 1465 dhcpmsg(MSG_VERBOSE, "rtsock_event: %s still has %d " 1466 "LIFs waiting on DAD", dsmp->dsm_name, 1467 dsmp->dsm_lif_wait); 1468 continue; 1469 } 1470 1471 /* 1472 * If we have some failed LIFs, then handle them now. We'll 1473 * remove them from the list. Any leases that become empty are 1474 * also removed as part of the decline-generation process. 1475 */ 1476 if (dsmp->dsm_lif_down != 0) 1477 send_declines(dsmp); 1478 1479 if (dsmp->dsm_leases == NULL) { 1480 dsmp->dsm_bad_offers++; 1481 /* 1482 * For DHCPv6, we'll process the restart once we're 1483 * done sending Decline messages, because these are 1484 * supposed to be acknowledged. With DHCPv4, there's 1485 * no acknowledgment for a DECLINE, so after sending 1486 * it, we just restart right away. 1487 */ 1488 if (!dsmp->dsm_isv6) { 1489 dhcpmsg(MSG_VERBOSE, "rtsock_event: %s has no " 1490 "LIFs left", dsmp->dsm_name); 1491 dhcp_restart(dsmp); 1492 } 1493 } else { 1494 /* 1495 * If we're now up on at least some of the leases and 1496 * we were waiting for that, then kick off the rest of 1497 * configuration. Lease validation and DAD are done. 1498 */ 1499 dhcpmsg(MSG_VERBOSE, "rtsock_event: all LIFs verified " 1500 "on %s in %s state", dsmp->dsm_name, 1501 dhcp_state_to_string(oldstate)); 1502 if (oldstate == PRE_BOUND || 1503 oldstate == ADOPTING) 1504 dhcp_bound_complete(dsmp); 1505 if (oldstate == ADOPTING) 1506 dhcp_adopt_complete(dsmp); 1507 } 1508 } 1509 } 1510 1511 /* 1512 * check_cmd_allowed(): check whether the requested command is allowed in the 1513 * state specified. 1514 * 1515 * input: DHCPSTATE: current state 1516 * dhcp_ipc_type_t: requested command 1517 * output: boolean_t: B_TRUE if command is allowed in this state 1518 */ 1519 1520 boolean_t 1521 check_cmd_allowed(DHCPSTATE state, dhcp_ipc_type_t cmd) 1522 { 1523 return (ipc_cmd_allowed[state][cmd] != 0); 1524 } 1525 1526 static boolean_t 1527 is_iscsi_active(void) 1528 { 1529 int fd; 1530 int active = 0; 1531 1532 if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) != -1) { 1533 if (ioctl(fd, ISCSI_IS_ACTIVE, &active) != 0) 1534 active = 0; 1535 (void) close(fd); 1536 } 1537 1538 return (active != 0); 1539 } 1540