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