17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5004388ebScasper * Common Development and Distribution License (the "License"). 6004388ebScasper * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22e11c3f44Smeem * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #include <sys/types.h> 277c478bd9Sstevel@tonic-gate #include <stdlib.h> 28*3644994cSmeem #include <assert.h> 297c478bd9Sstevel@tonic-gate #include <errno.h> 307c478bd9Sstevel@tonic-gate #include <locale.h> 317c478bd9Sstevel@tonic-gate #include <string.h> 327c478bd9Sstevel@tonic-gate #include <unistd.h> 337c478bd9Sstevel@tonic-gate #include <signal.h> 347c478bd9Sstevel@tonic-gate #include <stdio.h> 35004388ebScasper #include <stdio_ext.h> 367c478bd9Sstevel@tonic-gate #include <dhcp_hostconf.h> 377c478bd9Sstevel@tonic-gate #include <dhcpagent_ipc.h> 38d04ccbb3Scarlsonj #include <dhcpagent_util.h> 397c478bd9Sstevel@tonic-gate #include <dhcpmsg.h> 407c478bd9Sstevel@tonic-gate #include <netinet/dhcp.h> 4169bb4bb4Scarlsonj #include <net/route.h> 4269bb4bb4Scarlsonj #include <sys/sockio.h> 436cefaae1SJack Meng #include <sys/stat.h> 446cefaae1SJack Meng #include <stropts.h> 456cefaae1SJack Meng #include <fcntl.h> 466cefaae1SJack Meng #include <sys/scsi/adapters/iscsi_if.h> 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate #include "async.h" 497c478bd9Sstevel@tonic-gate #include "agent.h" 507c478bd9Sstevel@tonic-gate #include "script_handler.h" 517c478bd9Sstevel@tonic-gate #include "util.h" 527c478bd9Sstevel@tonic-gate #include "class_id.h" 537c478bd9Sstevel@tonic-gate #include "states.h" 547c478bd9Sstevel@tonic-gate #include "packet.h" 55d04ccbb3Scarlsonj #include "interface.h" 56d04ccbb3Scarlsonj #include "defaults.h" 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 597c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" 607c478bd9Sstevel@tonic-gate #endif 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate iu_timer_id_t inactivity_id; 637c478bd9Sstevel@tonic-gate int class_id_len = 0; 647c478bd9Sstevel@tonic-gate char *class_id; 657c478bd9Sstevel@tonic-gate iu_eh_t *eh; 667c478bd9Sstevel@tonic-gate iu_tq_t *tq; 677c478bd9Sstevel@tonic-gate pid_t grandparent; 6869bb4bb4Scarlsonj int rtsock_fd; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate static boolean_t shutdown_started = B_FALSE; 717c478bd9Sstevel@tonic-gate static boolean_t do_adopt = B_FALSE; 727c478bd9Sstevel@tonic-gate static unsigned int debug_level = 0; 7369bb4bb4Scarlsonj static iu_eh_callback_t accept_event, ipc_event, rtsock_event; 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate /* 767c478bd9Sstevel@tonic-gate * The ipc_cmd_allowed[] table indicates which IPC commands are allowed in 777c478bd9Sstevel@tonic-gate * which states; a non-zero value indicates the command is permitted. 787c478bd9Sstevel@tonic-gate * 79d04ccbb3Scarlsonj * START is permitted if the state machine is fresh, or if we are in the 80d04ccbb3Scarlsonj * process of trying to obtain a lease (as a convenience to save the 81d04ccbb3Scarlsonj * administrator from having to do an explicit DROP). EXTEND, RELEASE, and 82d04ccbb3Scarlsonj * GET_TAG require a lease to be obtained in order to make sense. INFORM is 83d04ccbb3Scarlsonj * permitted if the interface is fresh or has an INFORM in progress or 84d04ccbb3Scarlsonj * previously done on it -- otherwise a DROP or RELEASE is first required. 85d04ccbb3Scarlsonj * PING and STATUS always make sense and thus are always permitted, as is DROP 86d04ccbb3Scarlsonj * in order to permit the administrator to always bail out. 877c478bd9Sstevel@tonic-gate */ 887c478bd9Sstevel@tonic-gate static int ipc_cmd_allowed[DHCP_NSTATES][DHCP_NIPC] = { 897c478bd9Sstevel@tonic-gate /* D E P R S S I G */ 907c478bd9Sstevel@tonic-gate /* R X I E T T N E */ 917c478bd9Sstevel@tonic-gate /* O T N L A A F T */ 927c478bd9Sstevel@tonic-gate /* P E G E R T O _ */ 937c478bd9Sstevel@tonic-gate /* . N . A T U R T */ 947c478bd9Sstevel@tonic-gate /* . D . S . S M A */ 957c478bd9Sstevel@tonic-gate /* . . . E . . . G */ 967c478bd9Sstevel@tonic-gate /* INIT */ { 1, 0, 1, 0, 1, 1, 1, 0 }, 977c478bd9Sstevel@tonic-gate /* SELECTING */ { 1, 0, 1, 0, 1, 1, 0, 0 }, 987c478bd9Sstevel@tonic-gate /* REQUESTING */ { 1, 0, 1, 0, 1, 1, 0, 0 }, 9969bb4bb4Scarlsonj /* PRE_BOUND */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 1007c478bd9Sstevel@tonic-gate /* BOUND */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 1017c478bd9Sstevel@tonic-gate /* RENEWING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 1027c478bd9Sstevel@tonic-gate /* REBINDING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 103d04ccbb3Scarlsonj /* INFORMATION */ { 1, 0, 1, 0, 1, 1, 1, 1 }, 104d04ccbb3Scarlsonj /* INIT_REBOOT */ { 1, 0, 1, 1, 1, 1, 0, 0 }, 105d04ccbb3Scarlsonj /* ADOPTING */ { 1, 0, 1, 1, 0, 1, 0, 0 }, 106d04ccbb3Scarlsonj /* INFORM_SENT */ { 1, 0, 1, 0, 1, 1, 1, 0 }, 107d04ccbb3Scarlsonj /* DECLINING */ { 1, 1, 1, 1, 0, 1, 0, 1 }, 108d04ccbb3Scarlsonj /* RELEASING */ { 1, 0, 1, 0, 0, 1, 0, 1 }, 109d04ccbb3Scarlsonj }; 110d04ccbb3Scarlsonj 111d04ccbb3Scarlsonj #define CMD_ISPRIV 0x1 /* Command requires privileges */ 112d04ccbb3Scarlsonj #define CMD_CREATE 0x2 /* Command creates an interface */ 113d04ccbb3Scarlsonj #define CMD_BOOTP 0x4 /* Command is valid with BOOTP */ 114d04ccbb3Scarlsonj #define CMD_IMMED 0x8 /* Reply is immediate (no BUSY state) */ 115d04ccbb3Scarlsonj 116d04ccbb3Scarlsonj static uint_t ipc_cmd_flags[DHCP_NIPC] = { 117d04ccbb3Scarlsonj /* DHCP_DROP */ CMD_ISPRIV|CMD_BOOTP, 118d04ccbb3Scarlsonj /* DHCP_EXTEND */ CMD_ISPRIV, 119d04ccbb3Scarlsonj /* DHCP_PING */ CMD_BOOTP|CMD_IMMED, 120d04ccbb3Scarlsonj /* DHCP_RELEASE */ CMD_ISPRIV, 121d04ccbb3Scarlsonj /* DHCP_START */ CMD_CREATE|CMD_ISPRIV|CMD_BOOTP, 122d04ccbb3Scarlsonj /* DHCP_STATUS */ CMD_BOOTP|CMD_IMMED, 123d04ccbb3Scarlsonj /* DHCP_INFORM */ CMD_CREATE|CMD_ISPRIV, 124d04ccbb3Scarlsonj /* DHCP_GET_TAG */ CMD_BOOTP|CMD_IMMED 1257c478bd9Sstevel@tonic-gate }; 1267c478bd9Sstevel@tonic-gate 127*3644994cSmeem static boolean_t is_iscsi_active(void); 1286cefaae1SJack Meng 1297c478bd9Sstevel@tonic-gate int 1307c478bd9Sstevel@tonic-gate main(int argc, char **argv) 1317c478bd9Sstevel@tonic-gate { 1327c478bd9Sstevel@tonic-gate boolean_t is_daemon = B_TRUE; 133d04ccbb3Scarlsonj boolean_t is_verbose; 1347c478bd9Sstevel@tonic-gate int ipc_fd; 1357c478bd9Sstevel@tonic-gate int c; 136e11c3f44Smeem int aware = RTAW_UNDER_IPMP; 1377c478bd9Sstevel@tonic-gate struct rlimit rl; 1387c478bd9Sstevel@tonic-gate 139d04ccbb3Scarlsonj debug_level = df_get_int("", B_FALSE, DF_DEBUG_LEVEL); 140d04ccbb3Scarlsonj is_verbose = df_get_bool("", B_FALSE, DF_VERBOSE); 141d04ccbb3Scarlsonj 1427c478bd9Sstevel@tonic-gate /* 1437c478bd9Sstevel@tonic-gate * -l is ignored for compatibility with old agent. 1447c478bd9Sstevel@tonic-gate */ 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate while ((c = getopt(argc, argv, "vd:l:fa")) != EOF) { 1477c478bd9Sstevel@tonic-gate 1487c478bd9Sstevel@tonic-gate switch (c) { 1497c478bd9Sstevel@tonic-gate 1507c478bd9Sstevel@tonic-gate case 'a': 1517c478bd9Sstevel@tonic-gate do_adopt = B_TRUE; 1527c478bd9Sstevel@tonic-gate grandparent = getpid(); 1537c478bd9Sstevel@tonic-gate break; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate case 'd': 1567c478bd9Sstevel@tonic-gate debug_level = strtoul(optarg, NULL, 0); 1577c478bd9Sstevel@tonic-gate break; 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate case 'f': 1607c478bd9Sstevel@tonic-gate is_daemon = B_FALSE; 1617c478bd9Sstevel@tonic-gate break; 1627c478bd9Sstevel@tonic-gate 1637c478bd9Sstevel@tonic-gate case 'v': 1647c478bd9Sstevel@tonic-gate is_verbose = B_TRUE; 1657c478bd9Sstevel@tonic-gate break; 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate case '?': 1687c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "usage: %s [-a] [-d n] [-f] [-v]" 1697c478bd9Sstevel@tonic-gate "\n", argv[0]); 1707c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate default: 1737c478bd9Sstevel@tonic-gate break; 1747c478bd9Sstevel@tonic-gate } 1757c478bd9Sstevel@tonic-gate } 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 1787c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate if (geteuid() != 0) { 1817c478bd9Sstevel@tonic-gate dhcpmsg_init(argv[0], B_FALSE, is_verbose, debug_level); 1827c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERROR, "must be super-user"); 1837c478bd9Sstevel@tonic-gate dhcpmsg_fini(); 1847c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate if (is_daemon && daemonize() == 0) { 1887c478bd9Sstevel@tonic-gate dhcpmsg_init(argv[0], B_FALSE, is_verbose, debug_level); 1897c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERR, "cannot become daemon, exiting"); 1907c478bd9Sstevel@tonic-gate dhcpmsg_fini(); 1917c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 1927c478bd9Sstevel@tonic-gate } 1937c478bd9Sstevel@tonic-gate 194d04ccbb3Scarlsonj /* 195d04ccbb3Scarlsonj * Seed the random number generator, since we're going to need it 196d04ccbb3Scarlsonj * to set transaction id's and for exponential backoff. 197d04ccbb3Scarlsonj */ 198d04ccbb3Scarlsonj srand48(gethrtime() ^ gethostid() ^ getpid()); 199d04ccbb3Scarlsonj 2007c478bd9Sstevel@tonic-gate dhcpmsg_init(argv[0], is_daemon, is_verbose, debug_level); 2017c478bd9Sstevel@tonic-gate (void) atexit(dhcpmsg_fini); 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate tq = iu_tq_create(); 2047c478bd9Sstevel@tonic-gate eh = iu_eh_create(); 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate if (eh == NULL || tq == NULL) { 2077c478bd9Sstevel@tonic-gate errno = ENOMEM; 2087c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERR, "cannot create timer queue or event handler"); 2097c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 2107c478bd9Sstevel@tonic-gate } 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate /* 2137c478bd9Sstevel@tonic-gate * ignore most signals that could be reasonably generated. 2147c478bd9Sstevel@tonic-gate */ 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate (void) signal(SIGTERM, graceful_shutdown); 2177c478bd9Sstevel@tonic-gate (void) signal(SIGQUIT, graceful_shutdown); 2187c478bd9Sstevel@tonic-gate (void) signal(SIGPIPE, SIG_IGN); 2197c478bd9Sstevel@tonic-gate (void) signal(SIGUSR1, SIG_IGN); 2207c478bd9Sstevel@tonic-gate (void) signal(SIGUSR2, SIG_IGN); 2217c478bd9Sstevel@tonic-gate (void) signal(SIGINT, SIG_IGN); 2227c478bd9Sstevel@tonic-gate (void) signal(SIGHUP, SIG_IGN); 2237c478bd9Sstevel@tonic-gate (void) signal(SIGCHLD, SIG_IGN); 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate /* 2267c478bd9Sstevel@tonic-gate * upon SIGTHAW we need to refresh any non-infinite leases. 2277c478bd9Sstevel@tonic-gate */ 2287c478bd9Sstevel@tonic-gate 229d04ccbb3Scarlsonj (void) iu_eh_register_signal(eh, SIGTHAW, refresh_smachs, NULL); 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate class_id = get_class_id(); 2327c478bd9Sstevel@tonic-gate if (class_id != NULL) 2337c478bd9Sstevel@tonic-gate class_id_len = strlen(class_id); 2347c478bd9Sstevel@tonic-gate else 2357c478bd9Sstevel@tonic-gate dhcpmsg(MSG_WARNING, "get_class_id failed, continuing " 2367c478bd9Sstevel@tonic-gate "with no vendor class id"); 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate /* 2397c478bd9Sstevel@tonic-gate * the inactivity timer is enabled any time there are no 2407c478bd9Sstevel@tonic-gate * interfaces under DHCP control. if DHCP_INACTIVITY_WAIT 2417c478bd9Sstevel@tonic-gate * seconds transpire without an interface under DHCP control, 2427c478bd9Sstevel@tonic-gate * the agent shuts down. 2437c478bd9Sstevel@tonic-gate */ 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate inactivity_id = iu_schedule_timer(tq, DHCP_INACTIVITY_WAIT, 2467c478bd9Sstevel@tonic-gate inactivity_shutdown, NULL); 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* 2497c478bd9Sstevel@tonic-gate * max out the number available descriptors, just in case.. 2507c478bd9Sstevel@tonic-gate */ 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate rl.rlim_cur = RLIM_INFINITY; 2537c478bd9Sstevel@tonic-gate rl.rlim_max = RLIM_INFINITY; 2547c478bd9Sstevel@tonic-gate if (setrlimit(RLIMIT_NOFILE, &rl) == -1) 2557c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERR, "setrlimit failed"); 2567c478bd9Sstevel@tonic-gate 257004388ebScasper (void) enable_extended_FILE_stdio(-1, -1); 258004388ebScasper 259d04ccbb3Scarlsonj /* 260d04ccbb3Scarlsonj * Create and bind default IP sockets used to control interfaces and to 261d04ccbb3Scarlsonj * catch stray packets. 262d04ccbb3Scarlsonj */ 263d04ccbb3Scarlsonj 264d04ccbb3Scarlsonj if (!dhcp_ip_default()) 265d04ccbb3Scarlsonj return (EXIT_FAILURE); 266d04ccbb3Scarlsonj 2677c478bd9Sstevel@tonic-gate /* 2687c478bd9Sstevel@tonic-gate * create the ipc channel that the agent will listen for 2697c478bd9Sstevel@tonic-gate * requests on, and register it with the event handler so that 2707c478bd9Sstevel@tonic-gate * `accept_event' will be called back. 2717c478bd9Sstevel@tonic-gate */ 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate switch (dhcp_ipc_init(&ipc_fd)) { 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate case 0: 2767c478bd9Sstevel@tonic-gate break; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate case DHCP_IPC_E_BIND: 2797c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERROR, "dhcp_ipc_init: cannot bind to port " 2807c478bd9Sstevel@tonic-gate "%i (agent already running?)", IPPORT_DHCPAGENT); 2817c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate default: 2847c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERROR, "dhcp_ipc_init failed"); 2857c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 2867c478bd9Sstevel@tonic-gate } 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate if (iu_register_event(eh, ipc_fd, POLLIN, accept_event, 0) == -1) { 2897c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERR, "cannot register ipc fd for messages"); 2907c478bd9Sstevel@tonic-gate return (EXIT_FAILURE); 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate 29369bb4bb4Scarlsonj /* 29469bb4bb4Scarlsonj * Create the global routing socket. This is used for monitoring 29569bb4bb4Scarlsonj * interface transitions, so that we learn about the kernel's Duplicate 29669bb4bb4Scarlsonj * Address Detection status, and for inserting and removing default 297d04ccbb3Scarlsonj * routes as learned from DHCP servers. Both v4 and v6 are handed 298d04ccbb3Scarlsonj * with this one socket. 29969bb4bb4Scarlsonj */ 300d04ccbb3Scarlsonj rtsock_fd = socket(PF_ROUTE, SOCK_RAW, 0); 30169bb4bb4Scarlsonj if (rtsock_fd == -1) { 30269bb4bb4Scarlsonj dhcpmsg(MSG_ERR, "cannot open routing socket"); 30369bb4bb4Scarlsonj return (EXIT_FAILURE); 30469bb4bb4Scarlsonj } 305e11c3f44Smeem 306e11c3f44Smeem /* 307e11c3f44Smeem * We're IPMP-aware and can manage IPMP test addresses, so issue 308e11c3f44Smeem * RT_AWARE to get routing socket messages for interfaces under IPMP. 309e11c3f44Smeem */ 310e11c3f44Smeem if (setsockopt(rtsock_fd, SOL_ROUTE, RT_AWARE, &aware, 311e11c3f44Smeem sizeof (aware)) == -1) { 312e11c3f44Smeem dhcpmsg(MSG_ERR, "cannot set RT_AWARE on routing socket"); 313e11c3f44Smeem return (EXIT_FAILURE); 314e11c3f44Smeem } 315e11c3f44Smeem 31669bb4bb4Scarlsonj if (iu_register_event(eh, rtsock_fd, POLLIN, rtsock_event, 0) == -1) { 31769bb4bb4Scarlsonj dhcpmsg(MSG_ERR, "cannot register routing socket for messages"); 31869bb4bb4Scarlsonj return (EXIT_FAILURE); 31969bb4bb4Scarlsonj } 32069bb4bb4Scarlsonj 3217c478bd9Sstevel@tonic-gate /* 3227c478bd9Sstevel@tonic-gate * if the -a (adopt) option was specified, try to adopt the 323dc041e83Scarlsonj * kernel-managed interface before we start. 3247c478bd9Sstevel@tonic-gate */ 3257c478bd9Sstevel@tonic-gate 326d04ccbb3Scarlsonj if (do_adopt && !dhcp_adopt()) 327dc041e83Scarlsonj return (EXIT_FAILURE); 3287c478bd9Sstevel@tonic-gate 329d04ccbb3Scarlsonj /* 330d04ccbb3Scarlsonj * For DHCPv6, we own all of the interfaces marked DHCPRUNNING. As 331d04ccbb3Scarlsonj * we're starting operation here, if there are any of those interfaces 332d04ccbb3Scarlsonj * lingering around, they're strays, and need to be removed. 333d04ccbb3Scarlsonj * 334d04ccbb3Scarlsonj * It might be nice to save these addresses off somewhere -- for both 335d04ccbb3Scarlsonj * v4 and v6 -- and use them as hints for later negotiation. 336d04ccbb3Scarlsonj */ 337d04ccbb3Scarlsonj remove_v6_strays(); 338d04ccbb3Scarlsonj 3397c478bd9Sstevel@tonic-gate /* 3407c478bd9Sstevel@tonic-gate * enter the main event loop; this is where all the real work 3417c478bd9Sstevel@tonic-gate * takes place (through registering events and scheduling timers). 3427c478bd9Sstevel@tonic-gate * this function only returns when the agent is shutting down. 3437c478bd9Sstevel@tonic-gate */ 3447c478bd9Sstevel@tonic-gate 3457c478bd9Sstevel@tonic-gate switch (iu_handle_events(eh, tq)) { 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate case -1: 3487c478bd9Sstevel@tonic-gate dhcpmsg(MSG_WARNING, "iu_handle_events exited abnormally"); 3497c478bd9Sstevel@tonic-gate break; 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate case DHCP_REASON_INACTIVITY: 3527c478bd9Sstevel@tonic-gate dhcpmsg(MSG_INFO, "no interfaces to manage, shutting down..."); 3537c478bd9Sstevel@tonic-gate break; 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate case DHCP_REASON_TERMINATE: 3567c478bd9Sstevel@tonic-gate dhcpmsg(MSG_INFO, "received SIGTERM, shutting down..."); 3577c478bd9Sstevel@tonic-gate break; 3587c478bd9Sstevel@tonic-gate 3597c478bd9Sstevel@tonic-gate case DHCP_REASON_SIGNAL: 3607c478bd9Sstevel@tonic-gate dhcpmsg(MSG_WARNING, "received unexpected signal, shutting " 3617c478bd9Sstevel@tonic-gate "down..."); 3627c478bd9Sstevel@tonic-gate break; 3637c478bd9Sstevel@tonic-gate } 3647c478bd9Sstevel@tonic-gate 3657c478bd9Sstevel@tonic-gate (void) iu_eh_unregister_signal(eh, SIGTHAW, NULL); 3667c478bd9Sstevel@tonic-gate 3677c478bd9Sstevel@tonic-gate iu_eh_destroy(eh); 3687c478bd9Sstevel@tonic-gate iu_tq_destroy(tq); 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate return (EXIT_SUCCESS); 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate /* 3747c478bd9Sstevel@tonic-gate * drain_script(): event loop callback during shutdown 3757c478bd9Sstevel@tonic-gate * 3767c478bd9Sstevel@tonic-gate * input: eh_t *: unused 3777c478bd9Sstevel@tonic-gate * void *: unused 3787c478bd9Sstevel@tonic-gate * output: boolean_t: B_TRUE if event loop should exit; B_FALSE otherwise 3797c478bd9Sstevel@tonic-gate */ 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate /* ARGSUSED */ 3827c478bd9Sstevel@tonic-gate boolean_t 3837c478bd9Sstevel@tonic-gate drain_script(iu_eh_t *ehp, void *arg) 3847c478bd9Sstevel@tonic-gate { 3857c478bd9Sstevel@tonic-gate if (shutdown_started == B_FALSE) { 3867c478bd9Sstevel@tonic-gate shutdown_started = B_TRUE; 3876cefaae1SJack Meng /* 3886cefaae1SJack Meng * Check if the system is diskless client and/or 3896cefaae1SJack Meng * there are active iSCSI sessions 3906cefaae1SJack Meng * 3916cefaae1SJack Meng * Do not drop the lease, or the system will be 3926cefaae1SJack Meng * unable to sync(dump) through nfs/iSCSI driver 3936cefaae1SJack Meng */ 3946cefaae1SJack Meng if (!do_adopt && !is_iscsi_active()) { 395d04ccbb3Scarlsonj nuke_smach_list(); 3966cefaae1SJack Meng } 3977c478bd9Sstevel@tonic-gate } 3987c478bd9Sstevel@tonic-gate return (script_count == 0); 3997c478bd9Sstevel@tonic-gate } 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate /* 4027c478bd9Sstevel@tonic-gate * accept_event(): accepts a new connection on the ipc socket and registers 4037c478bd9Sstevel@tonic-gate * to receive its messages with the event handler 4047c478bd9Sstevel@tonic-gate * 4057c478bd9Sstevel@tonic-gate * input: iu_eh_t *: unused 4067c478bd9Sstevel@tonic-gate * int: the file descriptor in the iu_eh_t * the connection came in on 4077c478bd9Sstevel@tonic-gate * (other arguments unused) 4087c478bd9Sstevel@tonic-gate * output: void 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate /* ARGSUSED */ 4127c478bd9Sstevel@tonic-gate static void 4137c478bd9Sstevel@tonic-gate accept_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 4147c478bd9Sstevel@tonic-gate { 4157c478bd9Sstevel@tonic-gate int client_fd; 4167c478bd9Sstevel@tonic-gate int is_priv; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate if (dhcp_ipc_accept(fd, &client_fd, &is_priv) != 0) { 4197c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERR, "accept_event: accept on ipc socket"); 4207c478bd9Sstevel@tonic-gate return; 4217c478bd9Sstevel@tonic-gate } 4227c478bd9Sstevel@tonic-gate 4237c478bd9Sstevel@tonic-gate if (iu_register_event(eh, client_fd, POLLIN, ipc_event, 4247c478bd9Sstevel@tonic-gate (void *)is_priv) == -1) { 4257c478bd9Sstevel@tonic-gate dhcpmsg(MSG_ERROR, "accept_event: cannot register ipc socket " 4267c478bd9Sstevel@tonic-gate "for callback"); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate /* 4317c478bd9Sstevel@tonic-gate * ipc_event(): processes incoming ipc requests 4327c478bd9Sstevel@tonic-gate * 4337c478bd9Sstevel@tonic-gate * input: iu_eh_t *: unused 4347c478bd9Sstevel@tonic-gate * int: the file descriptor in the iu_eh_t * the request came in on 4357c478bd9Sstevel@tonic-gate * short: unused 436d04ccbb3Scarlsonj * iu_event_id_t: event ID 4377c478bd9Sstevel@tonic-gate * void *: indicates whether the request is from a privileged client 4387c478bd9Sstevel@tonic-gate * output: void 4397c478bd9Sstevel@tonic-gate */ 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate /* ARGSUSED */ 4427c478bd9Sstevel@tonic-gate static void 4437c478bd9Sstevel@tonic-gate ipc_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 4447c478bd9Sstevel@tonic-gate { 445d04ccbb3Scarlsonj ipc_action_t ia, *iap; 446d04ccbb3Scarlsonj dhcp_smach_t *dsmp; 4477c478bd9Sstevel@tonic-gate int error, is_priv = (int)arg; 448d04ccbb3Scarlsonj const char *ifname; 449d04ccbb3Scarlsonj boolean_t isv6; 450d04ccbb3Scarlsonj 451d04ccbb3Scarlsonj ipc_action_init(&ia); 452d04ccbb3Scarlsonj error = dhcp_ipc_recv_request(fd, &ia.ia_request, 453d04ccbb3Scarlsonj DHCP_IPC_REQUEST_WAIT); 454d04ccbb3Scarlsonj if (error != DHCP_IPC_SUCCESS) { 455d04ccbb3Scarlsonj if (error != DHCP_IPC_E_EOF) { 456d04ccbb3Scarlsonj dhcpmsg(MSG_ERROR, 457d04ccbb3Scarlsonj "ipc_event: dhcp_ipc_recv_request failed: %s", 458d04ccbb3Scarlsonj dhcp_ipc_strerror(error)); 459d04ccbb3Scarlsonj } else { 460d04ccbb3Scarlsonj dhcpmsg(MSG_DEBUG, "ipc_event: connection closed"); 461d04ccbb3Scarlsonj } 462d04ccbb3Scarlsonj if ((dsmp = lookup_smach_by_event(id)) != NULL) { 463d04ccbb3Scarlsonj ipc_action_finish(dsmp, error); 464d04ccbb3Scarlsonj } else { 465d04ccbb3Scarlsonj (void) iu_unregister_event(eh, id, NULL); 466d04ccbb3Scarlsonj (void) dhcp_ipc_close(fd); 467d04ccbb3Scarlsonj } 4687c478bd9Sstevel@tonic-gate return; 4697c478bd9Sstevel@tonic-gate } 4707c478bd9Sstevel@tonic-gate 471d04ccbb3Scarlsonj /* Fill in temporary ipc_action structure for utility functions */ 472d04ccbb3Scarlsonj ia.ia_cmd = DHCP_IPC_CMD(ia.ia_request->message_type); 473d04ccbb3Scarlsonj ia.ia_fd = fd; 474d04ccbb3Scarlsonj ia.ia_eid = id; 475d04ccbb3Scarlsonj 476d04ccbb3Scarlsonj if (ia.ia_cmd >= DHCP_NIPC) { 477d04ccbb3Scarlsonj dhcpmsg(MSG_ERROR, 478d04ccbb3Scarlsonj "ipc_event: invalid command (%s) attempted on %s", 479d04ccbb3Scarlsonj dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname); 480d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_CMD_UNKNOWN); 4817c478bd9Sstevel@tonic-gate return; 4827c478bd9Sstevel@tonic-gate } 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate /* return EPERM for any of the privileged actions */ 4857c478bd9Sstevel@tonic-gate 486d04ccbb3Scarlsonj if (!is_priv && (ipc_cmd_flags[ia.ia_cmd] & CMD_ISPRIV)) { 487d04ccbb3Scarlsonj dhcpmsg(MSG_WARNING, 488d04ccbb3Scarlsonj "ipc_event: privileged ipc command (%s) attempted on %s", 489d04ccbb3Scarlsonj dhcp_ipc_type_to_string(ia.ia_cmd), ia.ia_request->ifname); 490d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_PERM); 491d04ccbb3Scarlsonj return; 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate /* 495d04ccbb3Scarlsonj * Try to locate the state machine associated with this command. If 496d04ccbb3Scarlsonj * the command is DHCP_START or DHCP_INFORM and there isn't a state 497d04ccbb3Scarlsonj * machine already, make one (there may already be one from a previous 498d04ccbb3Scarlsonj * failed attempt to START or INFORM). Otherwise, verify the reference 499d04ccbb3Scarlsonj * is still valid. 500d04ccbb3Scarlsonj * 501d04ccbb3Scarlsonj * The interface name may be blank. In that case, we look up the 502d04ccbb3Scarlsonj * primary interface, and the requested type (v4 or v6) doesn't matter. 5037c478bd9Sstevel@tonic-gate */ 5047c478bd9Sstevel@tonic-gate 505d04ccbb3Scarlsonj isv6 = (ia.ia_request->message_type & DHCP_V6) != 0; 506d04ccbb3Scarlsonj ifname = ia.ia_request->ifname; 507d04ccbb3Scarlsonj if (*ifname == '\0') 508d04ccbb3Scarlsonj dsmp = primary_smach(isv6); 509d04ccbb3Scarlsonj else 510d04ccbb3Scarlsonj dsmp = lookup_smach(ifname, isv6); 5117c478bd9Sstevel@tonic-gate 512d04ccbb3Scarlsonj if (dsmp != NULL) { 513d04ccbb3Scarlsonj /* Note that verify_smach drops a reference */ 514d04ccbb3Scarlsonj hold_smach(dsmp); 515d04ccbb3Scarlsonj if (!verify_smach(dsmp)) 516d04ccbb3Scarlsonj dsmp = NULL; 517d04ccbb3Scarlsonj } 5187c478bd9Sstevel@tonic-gate 519d04ccbb3Scarlsonj if (dsmp == NULL) { 5207c478bd9Sstevel@tonic-gate /* 521d04ccbb3Scarlsonj * If the user asked for the primary DHCP interface, but there 522d04ccbb3Scarlsonj * is none, then report failure. 5237c478bd9Sstevel@tonic-gate */ 524d04ccbb3Scarlsonj if (ifname[0] == '\0') { 525d04ccbb3Scarlsonj error = DHCP_IPC_E_NOPRIMARY; 5267c478bd9Sstevel@tonic-gate 5277c478bd9Sstevel@tonic-gate /* 528d04ccbb3Scarlsonj * If there's no interface, and we're starting up, then create 529d04ccbb3Scarlsonj * it now, along with a state machine for it. Note that if 530d04ccbb3Scarlsonj * insert_smach fails, it discards the LIF reference. 5317c478bd9Sstevel@tonic-gate */ 532d04ccbb3Scarlsonj } else if (ipc_cmd_flags[ia.ia_cmd] & CMD_CREATE) { 533d04ccbb3Scarlsonj dhcp_lif_t *lif; 5347c478bd9Sstevel@tonic-gate 535d04ccbb3Scarlsonj lif = attach_lif(ifname, isv6, &error); 536d04ccbb3Scarlsonj if (lif != NULL && 537d04ccbb3Scarlsonj (dsmp = insert_smach(lif, &error)) != NULL) { 538d04ccbb3Scarlsonj /* 539d04ccbb3Scarlsonj * Get client ID and set "DHCPRUNNING" flag on 540d04ccbb3Scarlsonj * logical interface. (V4 only, because V6 541d04ccbb3Scarlsonj * plumbs its own interfaces.) 542d04ccbb3Scarlsonj */ 543d04ccbb3Scarlsonj error = get_smach_cid(dsmp); 544d04ccbb3Scarlsonj if (error == DHCP_IPC_SUCCESS) 545d04ccbb3Scarlsonj error = set_lif_dhcp(lif, B_FALSE); 546d04ccbb3Scarlsonj if (error != DHCP_IPC_SUCCESS) { 5473589885cScarlsonj remove_smach(dsmp); 548d04ccbb3Scarlsonj dsmp = NULL; 549d04ccbb3Scarlsonj } 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 552d04ccbb3Scarlsonj /* 553d04ccbb3Scarlsonj * Otherwise, this is an operation on an unknown interface. 554d04ccbb3Scarlsonj */ 555d04ccbb3Scarlsonj } else { 556d04ccbb3Scarlsonj error = DHCP_IPC_E_UNKIF; 557d04ccbb3Scarlsonj } 558d04ccbb3Scarlsonj if (dsmp == NULL) { 559d04ccbb3Scarlsonj send_error_reply(&ia, error); 5607c478bd9Sstevel@tonic-gate return; 5617c478bd9Sstevel@tonic-gate } 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 564d04ccbb3Scarlsonj if ((dsmp->dsm_dflags & DHCP_IF_BOOTP) && 565d04ccbb3Scarlsonj !(ipc_cmd_flags[ia.ia_cmd] & CMD_BOOTP)) { 566d04ccbb3Scarlsonj dhcpmsg(MSG_ERROR, "command %s not valid for BOOTP on %s", 567d04ccbb3Scarlsonj dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 568d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_BOOTP); 5697c478bd9Sstevel@tonic-gate return; 5707c478bd9Sstevel@tonic-gate } 5717c478bd9Sstevel@tonic-gate 5727c478bd9Sstevel@tonic-gate /* 573d04ccbb3Scarlsonj * verify that the state machine is in a state which will allow the 5747c478bd9Sstevel@tonic-gate * command. we do this up front so that we can return an error 5757c478bd9Sstevel@tonic-gate * *before* needlessly cancelling an in-progress transaction. 5767c478bd9Sstevel@tonic-gate */ 5777c478bd9Sstevel@tonic-gate 578d04ccbb3Scarlsonj if (!check_cmd_allowed(dsmp->dsm_state, ia.ia_cmd)) { 579d04ccbb3Scarlsonj dhcpmsg(MSG_DEBUG, 580d04ccbb3Scarlsonj "in state %s; not allowing %s command on %s", 581d04ccbb3Scarlsonj dhcp_state_to_string(dsmp->dsm_state), 582d04ccbb3Scarlsonj dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 583d04ccbb3Scarlsonj send_error_reply(&ia, 584d04ccbb3Scarlsonj ia.ia_cmd == DHCP_START && dsmp->dsm_state != INIT ? 585d04ccbb3Scarlsonj DHCP_IPC_E_RUNNING : DHCP_IPC_E_OUTSTATE); 5867c478bd9Sstevel@tonic-gate return; 5877c478bd9Sstevel@tonic-gate } 5887c478bd9Sstevel@tonic-gate 589d04ccbb3Scarlsonj dhcpmsg(MSG_DEBUG, "in state %s; allowing %s command on %s", 590d04ccbb3Scarlsonj dhcp_state_to_string(dsmp->dsm_state), 591d04ccbb3Scarlsonj dhcp_ipc_type_to_string(ia.ia_cmd), dsmp->dsm_name); 592d04ccbb3Scarlsonj 593d04ccbb3Scarlsonj if ((ia.ia_request->message_type & DHCP_PRIMARY) && is_priv) 594d04ccbb3Scarlsonj make_primary(dsmp); 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate /* 597d04ccbb3Scarlsonj * The current design dictates that there can be only one outstanding 598d04ccbb3Scarlsonj * transaction per state machine -- this simplifies the code 599d04ccbb3Scarlsonj * considerably and also fits well with RFCs 2131 and 3315. It is 600d04ccbb3Scarlsonj * worth classifying the different DHCP commands into synchronous 601d04ccbb3Scarlsonj * (those which we will handle now and reply to immediately) and 602d04ccbb3Scarlsonj * asynchronous (those which require transactions and will be completed 603d04ccbb3Scarlsonj * at an indeterminate time in the future): 6047c478bd9Sstevel@tonic-gate * 605d04ccbb3Scarlsonj * DROP: removes the agent's management of a state machine. 6067c478bd9Sstevel@tonic-gate * asynchronous as the script program may be invoked. 6077c478bd9Sstevel@tonic-gate * 608d04ccbb3Scarlsonj * PING: checks to see if the agent has a named state machine. 6097c478bd9Sstevel@tonic-gate * synchronous, since no packets need to be sent 6107c478bd9Sstevel@tonic-gate * to the DHCP server. 6117c478bd9Sstevel@tonic-gate * 612d04ccbb3Scarlsonj * STATUS: returns information about a state machine. 6137c478bd9Sstevel@tonic-gate * synchronous, since no packets need to be sent 6147c478bd9Sstevel@tonic-gate * to the DHCP server. 6157c478bd9Sstevel@tonic-gate * 616d04ccbb3Scarlsonj * RELEASE: releases the agent's management of a state machine 617d04ccbb3Scarlsonj * and brings the associated interfaces down. asynchronous 618d04ccbb3Scarlsonj * as the script program may be invoked. 6197c478bd9Sstevel@tonic-gate * 6207c478bd9Sstevel@tonic-gate * EXTEND: renews a lease. asynchronous, since the agent 6217c478bd9Sstevel@tonic-gate * needs to wait for an ACK, etc. 6227c478bd9Sstevel@tonic-gate * 623d04ccbb3Scarlsonj * START: starts DHCP on a named state machine. asynchronous since 6247c478bd9Sstevel@tonic-gate * the agent needs to wait for OFFERs, ACKs, etc. 6257c478bd9Sstevel@tonic-gate * 626d04ccbb3Scarlsonj * INFORM: obtains configuration parameters for the system using 627d04ccbb3Scarlsonj * externally configured interface. asynchronous, since the 6287c478bd9Sstevel@tonic-gate * agent needs to wait for an ACK. 6297c478bd9Sstevel@tonic-gate * 630d04ccbb3Scarlsonj * Notice that EXTEND, INFORM, START, DROP and RELEASE are 631d04ccbb3Scarlsonj * asynchronous. Notice also that asynchronous commands may occur from 632d04ccbb3Scarlsonj * within the agent -- for instance, the agent will need to do implicit 633d04ccbb3Scarlsonj * EXTENDs to extend the lease. In order to make the code simpler, the 634d04ccbb3Scarlsonj * following rules apply for asynchronous commands: 6357c478bd9Sstevel@tonic-gate * 636d04ccbb3Scarlsonj * There can only be one asynchronous command at a time per state 637d04ccbb3Scarlsonj * machine. The current asynchronous command is managed by the async_* 638d04ccbb3Scarlsonj * api: async_start(), async_finish(), and async_cancel(). 639d04ccbb3Scarlsonj * async_start() starts management of a new asynchronous command on an 640d04ccbb3Scarlsonj * state machine, which should only be done after async_cancel() to 641d04ccbb3Scarlsonj * terminate a previous command. When the command is completed, 642d04ccbb3Scarlsonj * async_finish() should be called. 6437c478bd9Sstevel@tonic-gate * 644d04ccbb3Scarlsonj * Asynchronous commands started by a user command have an associated 645d04ccbb3Scarlsonj * ipc_action which provides the agent with information for how to get 646d04ccbb3Scarlsonj * in touch with the user command when the action completes. These 647d04ccbb3Scarlsonj * ipc_action records also have an associated timeout which may be 648d04ccbb3Scarlsonj * infinite. ipc_action_start() should be called when starting an 649d04ccbb3Scarlsonj * asynchronous command requested by a user, which sets up the timer 650d04ccbb3Scarlsonj * and keeps track of the ipc information (file descriptor, request 651d04ccbb3Scarlsonj * type). When the asynchronous command completes, ipc_action_finish() 652d04ccbb3Scarlsonj * should be called to return a command status code to the user and 653d04ccbb3Scarlsonj * close the ipc connection). If the command does not complete before 654d04ccbb3Scarlsonj * the timer fires, ipc_action_timeout() is called which closes the ipc 655d04ccbb3Scarlsonj * connection and returns DHCP_IPC_E_TIMEOUT to the user. Note that 656d04ccbb3Scarlsonj * independent of ipc_action_timeout(), ipc_action_finish() should be 657d04ccbb3Scarlsonj * called. 6587c478bd9Sstevel@tonic-gate * 659d04ccbb3Scarlsonj * on a case-by-case basis, here is what happens (per state machine): 6607c478bd9Sstevel@tonic-gate * 661d04ccbb3Scarlsonj * o When an asynchronous command is requested, then 662d04ccbb3Scarlsonj * async_cancel() is called to terminate any non-user 663d04ccbb3Scarlsonj * action in progress. If there's a user action running, 6647c478bd9Sstevel@tonic-gate * the user command is sent DHCP_IPC_E_PEND. 6657c478bd9Sstevel@tonic-gate * 6667c478bd9Sstevel@tonic-gate * o otherwise, the the transaction is started with 6677c478bd9Sstevel@tonic-gate * async_start(). if the transaction is on behalf 6687c478bd9Sstevel@tonic-gate * of a user, ipc_action_start() is called to keep 6697c478bd9Sstevel@tonic-gate * track of the ipc information and set up the 6707c478bd9Sstevel@tonic-gate * ipc_action timer. 6717c478bd9Sstevel@tonic-gate * 6727c478bd9Sstevel@tonic-gate * o if the command completes normally and before a 6737c478bd9Sstevel@tonic-gate * timeout fires, then async_finish() is called. 6747c478bd9Sstevel@tonic-gate * if there was an associated ipc_action, 6757c478bd9Sstevel@tonic-gate * ipc_action_finish() is called to complete it. 6767c478bd9Sstevel@tonic-gate * 6777c478bd9Sstevel@tonic-gate * o if the command fails before a timeout fires, then 678d04ccbb3Scarlsonj * async_finish() is called, and the state machine is 6797c478bd9Sstevel@tonic-gate * is returned to a known state based on the command. 6807c478bd9Sstevel@tonic-gate * if there was an associated ipc_action, 6817c478bd9Sstevel@tonic-gate * ipc_action_finish() is called to complete it. 6827c478bd9Sstevel@tonic-gate * 6837c478bd9Sstevel@tonic-gate * o if the ipc_action timer fires before command 6847c478bd9Sstevel@tonic-gate * completion, then DHCP_IPC_E_TIMEOUT is returned to 6857c478bd9Sstevel@tonic-gate * the user. however, the transaction continues to 6867c478bd9Sstevel@tonic-gate * be carried out asynchronously. 6877c478bd9Sstevel@tonic-gate */ 6887c478bd9Sstevel@tonic-gate 689d04ccbb3Scarlsonj if (ipc_cmd_flags[ia.ia_cmd] & CMD_IMMED) { 690d04ccbb3Scarlsonj /* 691d04ccbb3Scarlsonj * Only immediate commands (ping, status, get_tag) need to 692d04ccbb3Scarlsonj * worry about freeing ia through one of the reply functions 693d04ccbb3Scarlsonj * before returning. 694d04ccbb3Scarlsonj */ 695d04ccbb3Scarlsonj iap = &ia; 696d04ccbb3Scarlsonj } else { 6977c478bd9Sstevel@tonic-gate /* 6987c478bd9Sstevel@tonic-gate * if shutdown request has been received, send back an error. 6997c478bd9Sstevel@tonic-gate */ 7007c478bd9Sstevel@tonic-gate if (shutdown_started) { 701d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_OUTSTATE); 7027c478bd9Sstevel@tonic-gate return; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 705d04ccbb3Scarlsonj if (dsmp->dsm_dflags & DHCP_IF_BUSY) { 706d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_PEND); 7077c478bd9Sstevel@tonic-gate return; 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 710d04ccbb3Scarlsonj if (!ipc_action_start(dsmp, &ia)) { 7117c478bd9Sstevel@tonic-gate dhcpmsg(MSG_WARNING, "ipc_event: ipc_action_start " 712d04ccbb3Scarlsonj "failed for %s", dsmp->dsm_name); 713d04ccbb3Scarlsonj send_error_reply(&ia, DHCP_IPC_E_MEMORY); 7147c478bd9Sstevel@tonic-gate return; 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 717d04ccbb3Scarlsonj /* Action structure consumed by above function */ 718d04ccbb3Scarlsonj iap = &dsmp->dsm_ia; 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate 721d04ccbb3Scarlsonj switch (iap->ia_cmd) { 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate case DHCP_DROP: 7248ff86213Scarlsonj if (dsmp->dsm_droprelease) 7258ff86213Scarlsonj break; 7268ff86213Scarlsonj dsmp->dsm_droprelease = B_TRUE; 727*3644994cSmeem 728*3644994cSmeem /* 729*3644994cSmeem * Ensure that a timer associated with the existing state 730*3644994cSmeem * doesn't pop while we're waiting for the script to complete. 731*3644994cSmeem * (If so, chaos can result -- e.g., a timer causes us to end 732*3644994cSmeem * up in dhcp_selecting() would start acquiring a new lease on 733*3644994cSmeem * dsmp while our DHCP_DROP dismantling is ongoing.) 734*3644994cSmeem */ 735*3644994cSmeem cancel_smach_timers(dsmp); 736d04ccbb3Scarlsonj (void) script_start(dsmp, isv6 ? EVENT_DROP6 : EVENT_DROP, 737d04ccbb3Scarlsonj dhcp_drop, NULL, NULL); 738d04ccbb3Scarlsonj break; /* not an immediate function */ 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate case DHCP_EXTEND: 741d04ccbb3Scarlsonj (void) dhcp_extending(dsmp); 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate case DHCP_GET_TAG: { 7457c478bd9Sstevel@tonic-gate dhcp_optnum_t optnum; 746d04ccbb3Scarlsonj void *opt = NULL; 747d04ccbb3Scarlsonj uint_t optlen; 7487c478bd9Sstevel@tonic-gate boolean_t did_alloc = B_FALSE; 749d04ccbb3Scarlsonj PKT_LIST *ack = dsmp->dsm_ack; 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * verify the request makes sense. 7537c478bd9Sstevel@tonic-gate */ 7547c478bd9Sstevel@tonic-gate 755d04ccbb3Scarlsonj if (iap->ia_request->data_type != DHCP_TYPE_OPTNUM || 756d04ccbb3Scarlsonj iap->ia_request->data_length != sizeof (dhcp_optnum_t)) { 757d04ccbb3Scarlsonj send_error_reply(iap, DHCP_IPC_E_PROTO); 758d04ccbb3Scarlsonj break; 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate 761d04ccbb3Scarlsonj (void) memcpy(&optnum, iap->ia_request->buffer, 762d04ccbb3Scarlsonj sizeof (dhcp_optnum_t)); 763d04ccbb3Scarlsonj 7647c478bd9Sstevel@tonic-gate load_option: 7657c478bd9Sstevel@tonic-gate switch (optnum.category) { 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate case DSYM_SITE: /* FALLTHRU */ 7687c478bd9Sstevel@tonic-gate case DSYM_STANDARD: 769d04ccbb3Scarlsonj if (isv6) { 770d04ccbb3Scarlsonj opt = dhcpv6_pkt_option(ack, NULL, optnum.code, 771d04ccbb3Scarlsonj NULL); 772d04ccbb3Scarlsonj } else { 773d04ccbb3Scarlsonj if (optnum.code <= DHCP_LAST_OPT) 774d04ccbb3Scarlsonj opt = ack->opts[optnum.code]; 775d04ccbb3Scarlsonj } 7767c478bd9Sstevel@tonic-gate break; 7777c478bd9Sstevel@tonic-gate 7787c478bd9Sstevel@tonic-gate case DSYM_VENDOR: 779d04ccbb3Scarlsonj if (isv6) { 780d04ccbb3Scarlsonj dhcpv6_option_t *d6o; 781d04ccbb3Scarlsonj uint32_t ent; 7827c478bd9Sstevel@tonic-gate 783d04ccbb3Scarlsonj /* 784d04ccbb3Scarlsonj * Look through vendor options to find our 785d04ccbb3Scarlsonj * enterprise number. 786d04ccbb3Scarlsonj */ 787d04ccbb3Scarlsonj d6o = NULL; 788d04ccbb3Scarlsonj for (;;) { 789d04ccbb3Scarlsonj d6o = dhcpv6_pkt_option(ack, d6o, 790d04ccbb3Scarlsonj DHCPV6_OPT_VENDOR_OPT, &optlen); 791d04ccbb3Scarlsonj if (d6o == NULL) 792d04ccbb3Scarlsonj break; 793d04ccbb3Scarlsonj optlen -= sizeof (*d6o); 794d04ccbb3Scarlsonj if (optlen < sizeof (ent)) 795d04ccbb3Scarlsonj continue; 796d04ccbb3Scarlsonj (void) memcpy(&ent, d6o + 1, 797d04ccbb3Scarlsonj sizeof (ent)); 798d04ccbb3Scarlsonj if (ntohl(ent) != DHCPV6_SUN_ENT) 799d04ccbb3Scarlsonj continue; 800d04ccbb3Scarlsonj break; 801d04ccbb3Scarlsonj } 802d04ccbb3Scarlsonj if (d6o != NULL) { 803d04ccbb3Scarlsonj /* 804d04ccbb3Scarlsonj * Now find the requested vendor option 805d04ccbb3Scarlsonj * within the vendor options block. 806d04ccbb3Scarlsonj */ 807d04ccbb3Scarlsonj opt = dhcpv6_find_option( 808d04ccbb3Scarlsonj (char *)(d6o + 1) + sizeof (ent), 809d04ccbb3Scarlsonj optlen - sizeof (ent), NULL, 810d04ccbb3Scarlsonj optnum.code, NULL); 811d04ccbb3Scarlsonj } 812d04ccbb3Scarlsonj } else { 813d04ccbb3Scarlsonj /* 814d04ccbb3Scarlsonj * the test against VS_OPTION_START is broken 815d04ccbb3Scarlsonj * up into two tests to avoid compiler warnings 816d04ccbb3Scarlsonj * under intel. 817d04ccbb3Scarlsonj */ 818d04ccbb3Scarlsonj if ((optnum.code > VS_OPTION_START || 819d04ccbb3Scarlsonj optnum.code == VS_OPTION_START) && 820d04ccbb3Scarlsonj optnum.code <= VS_OPTION_END) 821d04ccbb3Scarlsonj opt = ack->vs[optnum.code]; 822d04ccbb3Scarlsonj } 8237c478bd9Sstevel@tonic-gate break; 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate case DSYM_FIELD: 826d04ccbb3Scarlsonj if (isv6) { 827d04ccbb3Scarlsonj dhcpv6_message_t *d6m = 828d04ccbb3Scarlsonj (dhcpv6_message_t *)ack->pkt; 829d04ccbb3Scarlsonj dhcpv6_option_t *d6o; 830d04ccbb3Scarlsonj 831d04ccbb3Scarlsonj /* Validate the packet field the user wants */ 832d04ccbb3Scarlsonj optlen = optnum.code + optnum.size; 833d04ccbb3Scarlsonj if (d6m->d6m_msg_type == 834d04ccbb3Scarlsonj DHCPV6_MSG_RELAY_FORW || 835d04ccbb3Scarlsonj d6m->d6m_msg_type == 836d04ccbb3Scarlsonj DHCPV6_MSG_RELAY_REPL) { 837d04ccbb3Scarlsonj if (optlen > sizeof (dhcpv6_relay_t)) 838d04ccbb3Scarlsonj break; 839d04ccbb3Scarlsonj } else { 840d04ccbb3Scarlsonj if (optlen > sizeof (*d6m)) 841d04ccbb3Scarlsonj break; 842d04ccbb3Scarlsonj } 843d04ccbb3Scarlsonj 844d04ccbb3Scarlsonj opt = malloc(sizeof (*d6o) + optnum.size); 845d04ccbb3Scarlsonj if (opt != NULL) { 846d04ccbb3Scarlsonj d6o = opt; 847d04ccbb3Scarlsonj d6o->d6o_code = htons(optnum.code); 848d04ccbb3Scarlsonj d6o->d6o_len = htons(optnum.size); 849d04ccbb3Scarlsonj (void) memcpy(d6o + 1, (caddr_t)d6m + 850d04ccbb3Scarlsonj optnum.code, optnum.size); 851d04ccbb3Scarlsonj } 852d04ccbb3Scarlsonj } else { 853d04ccbb3Scarlsonj if (optnum.code + optnum.size > sizeof (PKT)) 854d04ccbb3Scarlsonj break; 855d04ccbb3Scarlsonj 856d04ccbb3Scarlsonj /* 857d04ccbb3Scarlsonj * + 2 to account for option code and length 858d04ccbb3Scarlsonj * byte 859d04ccbb3Scarlsonj */ 860d04ccbb3Scarlsonj opt = malloc(optnum.size + 2); 861d04ccbb3Scarlsonj if (opt != NULL) { 862d04ccbb3Scarlsonj DHCP_OPT *v4opt = opt; 863d04ccbb3Scarlsonj 864d04ccbb3Scarlsonj v4opt->len = optnum.size; 865d04ccbb3Scarlsonj v4opt->code = optnum.code; 866d04ccbb3Scarlsonj (void) memcpy(v4opt->value, 867d04ccbb3Scarlsonj (caddr_t)ack->pkt + optnum.code, 868d04ccbb3Scarlsonj optnum.size); 869d04ccbb3Scarlsonj } 870d04ccbb3Scarlsonj } 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate if (opt == NULL) { 873d04ccbb3Scarlsonj send_error_reply(iap, DHCP_IPC_E_MEMORY); 8747c478bd9Sstevel@tonic-gate return; 8757c478bd9Sstevel@tonic-gate } 8767c478bd9Sstevel@tonic-gate did_alloc = B_TRUE; 8777c478bd9Sstevel@tonic-gate break; 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate default: 880d04ccbb3Scarlsonj send_error_reply(iap, DHCP_IPC_E_PROTO); 8817c478bd9Sstevel@tonic-gate return; 8827c478bd9Sstevel@tonic-gate } 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate /* 8857c478bd9Sstevel@tonic-gate * return the option payload, if there was one. the "+ 2" 8867c478bd9Sstevel@tonic-gate * accounts for the option code number and length byte. 8877c478bd9Sstevel@tonic-gate */ 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate if (opt != NULL) { 890d04ccbb3Scarlsonj if (isv6) { 891d04ccbb3Scarlsonj dhcpv6_option_t d6ov; 892d04ccbb3Scarlsonj 893d04ccbb3Scarlsonj (void) memcpy(&d6ov, opt, sizeof (d6ov)); 894d04ccbb3Scarlsonj optlen = ntohs(d6ov.d6o_len) + sizeof (d6ov); 895d04ccbb3Scarlsonj } else { 896d04ccbb3Scarlsonj optlen = ((DHCP_OPT *)opt)->len + 2; 897d04ccbb3Scarlsonj } 898d04ccbb3Scarlsonj send_data_reply(iap, 0, DHCP_TYPE_OPTION, opt, optlen); 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate if (did_alloc) 9017c478bd9Sstevel@tonic-gate free(opt); 902d04ccbb3Scarlsonj break; 903d04ccbb3Scarlsonj } else if (ack != dsmp->dsm_orig_ack) { 9047c478bd9Sstevel@tonic-gate /* 9057c478bd9Sstevel@tonic-gate * There wasn't any definition for the option in the 9067c478bd9Sstevel@tonic-gate * current ack, so now retry with the original ack if 9077c478bd9Sstevel@tonic-gate * the original ack is not the current ack. 9087c478bd9Sstevel@tonic-gate */ 909d04ccbb3Scarlsonj ack = dsmp->dsm_orig_ack; 9107c478bd9Sstevel@tonic-gate goto load_option; 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate /* 9147c478bd9Sstevel@tonic-gate * note that an "okay" response is returned either in 9157c478bd9Sstevel@tonic-gate * the case of an unknown option or a known option 9167c478bd9Sstevel@tonic-gate * with no payload. this is okay (for now) since 9177c478bd9Sstevel@tonic-gate * dhcpinfo checks whether an option is valid before 9187c478bd9Sstevel@tonic-gate * ever performing ipc with the agent. 9197c478bd9Sstevel@tonic-gate */ 9207c478bd9Sstevel@tonic-gate 921d04ccbb3Scarlsonj send_ok_reply(iap); 922d04ccbb3Scarlsonj break; 9237c478bd9Sstevel@tonic-gate } 9247c478bd9Sstevel@tonic-gate 9257c478bd9Sstevel@tonic-gate case DHCP_INFORM: 926d04ccbb3Scarlsonj dhcp_inform(dsmp); 9277c478bd9Sstevel@tonic-gate /* next destination: dhcp_acknak() */ 928d04ccbb3Scarlsonj break; /* not an immediate function */ 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate case DHCP_PING: 931d04ccbb3Scarlsonj if (dsmp->dsm_dflags & DHCP_IF_FAILED) 932d04ccbb3Scarlsonj send_error_reply(iap, DHCP_IPC_E_FAILEDIF); 9337c478bd9Sstevel@tonic-gate else 934d04ccbb3Scarlsonj send_ok_reply(iap); 935d04ccbb3Scarlsonj break; 9367c478bd9Sstevel@tonic-gate 9377c478bd9Sstevel@tonic-gate case DHCP_RELEASE: 9388ff86213Scarlsonj if (dsmp->dsm_droprelease) 9398ff86213Scarlsonj break; 9408ff86213Scarlsonj dsmp->dsm_droprelease = B_TRUE; 941*3644994cSmeem cancel_smach_timers(dsmp); /* see comment in DHCP_DROP above */ 942d04ccbb3Scarlsonj (void) script_start(dsmp, isv6 ? EVENT_RELEASE6 : 943d04ccbb3Scarlsonj EVENT_RELEASE, dhcp_release, "Finished with lease.", NULL); 944d04ccbb3Scarlsonj break; /* not an immediate function */ 945d04ccbb3Scarlsonj 946d04ccbb3Scarlsonj case DHCP_START: { 947d04ccbb3Scarlsonj PKT_LIST *ack, *oack; 948d04ccbb3Scarlsonj PKT_LIST *plp[2]; 9497c478bd9Sstevel@tonic-gate 950d04ccbb3Scarlsonj deprecate_leases(dsmp); 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * if we have a valid hostconf lying around, then jump 9547c478bd9Sstevel@tonic-gate * into INIT_REBOOT. if it fails, we'll end up going 9557c478bd9Sstevel@tonic-gate * through the whole selecting() procedure again. 9567c478bd9Sstevel@tonic-gate */ 9577c478bd9Sstevel@tonic-gate 958d04ccbb3Scarlsonj error = read_hostconf(dsmp->dsm_name, plp, 2, dsmp->dsm_isv6); 959d04ccbb3Scarlsonj ack = error > 0 ? plp[0] : NULL; 960d04ccbb3Scarlsonj oack = error > 1 ? plp[1] : NULL; 961d04ccbb3Scarlsonj 962d04ccbb3Scarlsonj /* 963d04ccbb3Scarlsonj * If the allocation of the old ack fails, that's fine; 964d04ccbb3Scarlsonj * continue without it. 965d04ccbb3Scarlsonj */ 966d04ccbb3Scarlsonj if (oack == NULL) 967d04ccbb3Scarlsonj oack = ack; 968d04ccbb3Scarlsonj 969d04ccbb3Scarlsonj /* 970d04ccbb3Scarlsonj * As long as we've allocated something, start using it. 971d04ccbb3Scarlsonj */ 972d04ccbb3Scarlsonj if (ack != NULL) { 973d04ccbb3Scarlsonj dsmp->dsm_orig_ack = oack; 974d04ccbb3Scarlsonj dsmp->dsm_ack = ack; 975d04ccbb3Scarlsonj dhcp_init_reboot(dsmp); 9767c478bd9Sstevel@tonic-gate /* next destination: dhcp_acknak() */ 977d04ccbb3Scarlsonj break; 9787c478bd9Sstevel@tonic-gate } 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate /* 9817c478bd9Sstevel@tonic-gate * if not debugging, wait for a few seconds before 9827c478bd9Sstevel@tonic-gate * going into SELECTING. 9837c478bd9Sstevel@tonic-gate */ 9847c478bd9Sstevel@tonic-gate 985cfb9c9abScarlsonj if (debug_level == 0 && set_start_timer(dsmp)) { 986d04ccbb3Scarlsonj /* next destination: dhcp_start() */ 987d04ccbb3Scarlsonj break; 988cfb9c9abScarlsonj } else { 989cfb9c9abScarlsonj dhcp_selecting(dsmp); 990cfb9c9abScarlsonj /* next destination: dhcp_requesting() */ 991cfb9c9abScarlsonj break; 9927c478bd9Sstevel@tonic-gate } 993d04ccbb3Scarlsonj } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate case DHCP_STATUS: { 9967c478bd9Sstevel@tonic-gate dhcp_status_t status; 997d04ccbb3Scarlsonj dhcp_lease_t *dlp; 998d04ccbb3Scarlsonj 999d04ccbb3Scarlsonj status.if_began = monosec_to_time(dsmp->dsm_curstart_monosec); 10007c478bd9Sstevel@tonic-gate 1001d04ccbb3Scarlsonj /* 1002d04ccbb3Scarlsonj * We return information on just the first lease as being 1003d04ccbb3Scarlsonj * representative of the lot. A better status mechanism is 1004d04ccbb3Scarlsonj * needed. 1005d04ccbb3Scarlsonj */ 1006d04ccbb3Scarlsonj dlp = dsmp->dsm_leases; 10077c478bd9Sstevel@tonic-gate 1008d04ccbb3Scarlsonj if (dlp == NULL || 1009d04ccbb3Scarlsonj dlp->dl_lifs->lif_expire.dt_start == DHCP_PERM) { 10107c478bd9Sstevel@tonic-gate status.if_t1 = DHCP_PERM; 10117c478bd9Sstevel@tonic-gate status.if_t2 = DHCP_PERM; 10127c478bd9Sstevel@tonic-gate status.if_lease = DHCP_PERM; 10137c478bd9Sstevel@tonic-gate } else { 1014d04ccbb3Scarlsonj status.if_t1 = status.if_began + 1015d04ccbb3Scarlsonj dlp->dl_t1.dt_start; 1016d04ccbb3Scarlsonj status.if_t2 = status.if_began + 1017d04ccbb3Scarlsonj dlp->dl_t2.dt_start; 1018d04ccbb3Scarlsonj status.if_lease = status.if_began + 1019d04ccbb3Scarlsonj dlp->dl_lifs->lif_expire.dt_start; 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate status.version = DHCP_STATUS_VER; 1023d04ccbb3Scarlsonj status.if_state = dsmp->dsm_state; 1024d04ccbb3Scarlsonj status.if_dflags = dsmp->dsm_dflags; 1025d04ccbb3Scarlsonj status.if_sent = dsmp->dsm_sent; 1026d04ccbb3Scarlsonj status.if_recv = dsmp->dsm_received; 1027d04ccbb3Scarlsonj status.if_bad_offers = dsmp->dsm_bad_offers; 10287c478bd9Sstevel@tonic-gate 102965c8f1c0Smeem (void) strlcpy(status.if_name, dsmp->dsm_name, LIFNAMSIZ); 10307c478bd9Sstevel@tonic-gate 1031d04ccbb3Scarlsonj send_data_reply(iap, 0, DHCP_TYPE_STATUS, &status, 10327c478bd9Sstevel@tonic-gate sizeof (dhcp_status_t)); 1033d04ccbb3Scarlsonj break; 10347c478bd9Sstevel@tonic-gate } 10357c478bd9Sstevel@tonic-gate } 10367c478bd9Sstevel@tonic-gate } 103769bb4bb4Scarlsonj 103869bb4bb4Scarlsonj /* 103969bb4bb4Scarlsonj * check_rtm_addr(): determine if routing socket message matches interface 104069bb4bb4Scarlsonj * address 104169bb4bb4Scarlsonj * 1042d04ccbb3Scarlsonj * input: const struct if_msghdr *: pointer to routing socket message 1043d04ccbb3Scarlsonj * int: routing socket message length 1044d04ccbb3Scarlsonj * boolean_t: set to B_TRUE if IPv6 1045d04ccbb3Scarlsonj * const in6_addr_t *: pointer to IP address 1046d04ccbb3Scarlsonj * output: boolean_t: B_TRUE if address is a match 104769bb4bb4Scarlsonj */ 1048d04ccbb3Scarlsonj 104969bb4bb4Scarlsonj static boolean_t 1050d04ccbb3Scarlsonj check_rtm_addr(const struct ifa_msghdr *ifam, int msglen, boolean_t isv6, 1051d04ccbb3Scarlsonj const in6_addr_t *addr) 105269bb4bb4Scarlsonj { 1053d04ccbb3Scarlsonj const char *cp, *lim; 105469bb4bb4Scarlsonj uint_t flag; 1055d04ccbb3Scarlsonj const struct sockaddr *sa; 105669bb4bb4Scarlsonj 105769bb4bb4Scarlsonj if (!(ifam->ifam_addrs & RTA_IFA)) 105869bb4bb4Scarlsonj return (B_FALSE); 105969bb4bb4Scarlsonj 1060d04ccbb3Scarlsonj cp = (const char *)(ifam + 1); 1061d04ccbb3Scarlsonj lim = (const char *)ifam + msglen; 106269bb4bb4Scarlsonj for (flag = 1; flag < RTA_IFA; flag <<= 1) { 106369bb4bb4Scarlsonj if (ifam->ifam_addrs & flag) { 106469bb4bb4Scarlsonj /* LINTED: alignment */ 1065d04ccbb3Scarlsonj sa = (const struct sockaddr *)cp; 1066d04ccbb3Scarlsonj if ((const char *)(sa + 1) > lim) 106769bb4bb4Scarlsonj return (B_FALSE); 106869bb4bb4Scarlsonj switch (sa->sa_family) { 106969bb4bb4Scarlsonj case AF_INET: 107069bb4bb4Scarlsonj cp += sizeof (struct sockaddr_in); 107169bb4bb4Scarlsonj break; 107269bb4bb4Scarlsonj case AF_LINK: 107369bb4bb4Scarlsonj cp += sizeof (struct sockaddr_dl); 107469bb4bb4Scarlsonj break; 107569bb4bb4Scarlsonj case AF_INET6: 107669bb4bb4Scarlsonj cp += sizeof (struct sockaddr_in6); 107769bb4bb4Scarlsonj break; 107869bb4bb4Scarlsonj default: 107969bb4bb4Scarlsonj cp += sizeof (struct sockaddr); 108069bb4bb4Scarlsonj break; 108169bb4bb4Scarlsonj } 108269bb4bb4Scarlsonj } 108369bb4bb4Scarlsonj } 1084d04ccbb3Scarlsonj if (isv6) { 1085d04ccbb3Scarlsonj const struct sockaddr_in6 *sin6; 1086d04ccbb3Scarlsonj 1087d04ccbb3Scarlsonj /* LINTED: alignment */ 1088d04ccbb3Scarlsonj sin6 = (const struct sockaddr_in6 *)cp; 1089d04ccbb3Scarlsonj if ((const char *)(sin6 + 1) > lim) 1090d04ccbb3Scarlsonj return (B_FALSE); 1091d04ccbb3Scarlsonj if (sin6->sin6_family != AF_INET6) 1092d04ccbb3Scarlsonj return (B_FALSE); 1093d04ccbb3Scarlsonj return (IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr, addr)); 1094d04ccbb3Scarlsonj } else { 1095d04ccbb3Scarlsonj const struct sockaddr_in *sinp; 1096d04ccbb3Scarlsonj ipaddr_t v4addr; 1097d04ccbb3Scarlsonj 1098d04ccbb3Scarlsonj /* LINTED: alignment */ 1099d04ccbb3Scarlsonj sinp = (const struct sockaddr_in *)cp; 1100d04ccbb3Scarlsonj if ((const char *)(sinp + 1) > lim) 1101d04ccbb3Scarlsonj return (B_FALSE); 1102d04ccbb3Scarlsonj if (sinp->sin_family != AF_INET) 1103d04ccbb3Scarlsonj return (B_FALSE); 1104d04ccbb3Scarlsonj IN6_V4MAPPED_TO_IPADDR(addr, v4addr); 1105d04ccbb3Scarlsonj return (sinp->sin_addr.s_addr == v4addr); 1106d04ccbb3Scarlsonj } 1107d04ccbb3Scarlsonj } 1108d04ccbb3Scarlsonj 1109d04ccbb3Scarlsonj /* 1110d04ccbb3Scarlsonj * is_rtm_v6(): determine if routing socket message is IPv6 1111d04ccbb3Scarlsonj * 1112d04ccbb3Scarlsonj * input: struct ifa_msghdr *: pointer to routing socket message 1113d04ccbb3Scarlsonj * int: message length 1114d04ccbb3Scarlsonj * output: boolean_t 1115d04ccbb3Scarlsonj */ 1116d04ccbb3Scarlsonj 1117d04ccbb3Scarlsonj static boolean_t 1118d04ccbb3Scarlsonj is_rtm_v6(const struct ifa_msghdr *ifam, int msglen) 1119d04ccbb3Scarlsonj { 1120d04ccbb3Scarlsonj const char *cp, *lim; 1121d04ccbb3Scarlsonj uint_t flag; 1122d04ccbb3Scarlsonj const struct sockaddr *sa; 1123d04ccbb3Scarlsonj 1124d04ccbb3Scarlsonj cp = (const char *)(ifam + 1); 1125d04ccbb3Scarlsonj lim = (const char *)ifam + msglen; 1126d04ccbb3Scarlsonj for (flag = ifam->ifam_addrs; flag != 0; flag &= flag - 1) { 1127d04ccbb3Scarlsonj /* LINTED: alignment */ 1128d04ccbb3Scarlsonj sa = (const struct sockaddr *)cp; 1129d04ccbb3Scarlsonj if ((const char *)(sa + 1) > lim) 1130d04ccbb3Scarlsonj return (B_FALSE); 1131d04ccbb3Scarlsonj switch (sa->sa_family) { 1132d04ccbb3Scarlsonj case AF_INET: 1133d04ccbb3Scarlsonj return (B_FALSE); 1134d04ccbb3Scarlsonj case AF_LINK: 1135d04ccbb3Scarlsonj cp += sizeof (struct sockaddr_dl); 1136d04ccbb3Scarlsonj break; 1137d04ccbb3Scarlsonj case AF_INET6: 1138d04ccbb3Scarlsonj return (B_TRUE); 1139d04ccbb3Scarlsonj default: 1140d04ccbb3Scarlsonj cp += sizeof (struct sockaddr); 1141d04ccbb3Scarlsonj break; 1142d04ccbb3Scarlsonj } 1143d04ccbb3Scarlsonj } 1144d04ccbb3Scarlsonj return (B_FALSE); 1145d04ccbb3Scarlsonj } 1146d04ccbb3Scarlsonj 1147d04ccbb3Scarlsonj /* 1148d04ccbb3Scarlsonj * check_lif(): check the state of a given logical interface and its DHCP 1149d04ccbb3Scarlsonj * lease. We've been told by the routing socket that the 1150d04ccbb3Scarlsonj * corresponding ifIndex has changed. This may mean that DAD has 1151d04ccbb3Scarlsonj * completed or failed. 1152d04ccbb3Scarlsonj * 1153d04ccbb3Scarlsonj * input: dhcp_lif_t *: pointer to the LIF 1154d04ccbb3Scarlsonj * const struct ifa_msghdr *: routing socket message 1155d04ccbb3Scarlsonj * int: size of routing socket message 1156d04ccbb3Scarlsonj * output: boolean_t: B_TRUE if DAD has completed on this interface 1157d04ccbb3Scarlsonj */ 1158d04ccbb3Scarlsonj 1159d04ccbb3Scarlsonj static boolean_t 1160d04ccbb3Scarlsonj check_lif(dhcp_lif_t *lif, const struct ifa_msghdr *ifam, int msglen) 1161d04ccbb3Scarlsonj { 1162d04ccbb3Scarlsonj boolean_t isv6, dad_wait, unplumb; 1163d04ccbb3Scarlsonj int fd; 1164d04ccbb3Scarlsonj struct lifreq lifr; 1165d04ccbb3Scarlsonj 1166d04ccbb3Scarlsonj isv6 = lif->lif_pif->pif_isv6; 1167d04ccbb3Scarlsonj fd = isv6 ? v6_sock_fd : v4_sock_fd; 1168d04ccbb3Scarlsonj 1169d04ccbb3Scarlsonj /* 1170d04ccbb3Scarlsonj * Get the real (64 bit) logical interface flags. Note that the 1171d04ccbb3Scarlsonj * routing socket message has flags, but these are just the lower 32 1172d04ccbb3Scarlsonj * bits. 1173d04ccbb3Scarlsonj */ 1174d04ccbb3Scarlsonj unplumb = B_FALSE; 1175d04ccbb3Scarlsonj (void) memset(&lifr, 0, sizeof (lifr)); 1176d04ccbb3Scarlsonj (void) strlcpy(lifr.lifr_name, lif->lif_name, sizeof (lifr.lifr_name)); 1177d04ccbb3Scarlsonj if (ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1) { 1178d04ccbb3Scarlsonj /* 1179d04ccbb3Scarlsonj * Failing to retrieve flags means that the interface is gone. 1180d04ccbb3Scarlsonj * It hasn't failed to verify with DAD, but we still have to 1181d04ccbb3Scarlsonj * give up on it. 1182d04ccbb3Scarlsonj */ 1183d04ccbb3Scarlsonj lifr.lifr_flags = 0; 1184d04ccbb3Scarlsonj if (errno == ENXIO) { 1185d04ccbb3Scarlsonj lif->lif_plumbed = B_FALSE; 1186d04ccbb3Scarlsonj dhcpmsg(MSG_INFO, "%s has been removed; abandoning", 1187d04ccbb3Scarlsonj lif->lif_name); 1188cfb9c9abScarlsonj if (!isv6) 1189cfb9c9abScarlsonj discard_default_routes(lif->lif_smachs); 1190d04ccbb3Scarlsonj } else { 1191d04ccbb3Scarlsonj dhcpmsg(MSG_ERR, 1192d04ccbb3Scarlsonj "unable to retrieve interface flags on %s", 1193d04ccbb3Scarlsonj lif->lif_name); 1194d04ccbb3Scarlsonj } 1195d04ccbb3Scarlsonj unplumb = B_TRUE; 1196d04ccbb3Scarlsonj } else if (!check_rtm_addr(ifam, msglen, isv6, &lif->lif_v6addr)) { 1197d04ccbb3Scarlsonj /* 1198d04ccbb3Scarlsonj * If the message is not about this logical interface, 1199d04ccbb3Scarlsonj * then just ignore it. 1200d04ccbb3Scarlsonj */ 120169bb4bb4Scarlsonj return (B_FALSE); 1202d04ccbb3Scarlsonj } else if (lifr.lifr_flags & IFF_DUPLICATE) { 1203d04ccbb3Scarlsonj dhcpmsg(MSG_ERROR, "interface %s has duplicate address", 1204d04ccbb3Scarlsonj lif->lif_name); 1205d04ccbb3Scarlsonj lif_mark_decline(lif, "duplicate address"); 1206d04ccbb3Scarlsonj close_ip_lif(lif); 1207e11c3f44Smeem (void) open_ip_lif(lif, INADDR_ANY, B_TRUE); 1208d04ccbb3Scarlsonj } 1209d04ccbb3Scarlsonj 1210d04ccbb3Scarlsonj dad_wait = lif->lif_dad_wait; 1211d04ccbb3Scarlsonj if (dad_wait) { 1212d04ccbb3Scarlsonj dhcpmsg(MSG_VERBOSE, "check_lif: %s has finished DAD", 1213d04ccbb3Scarlsonj lif->lif_name); 1214d04ccbb3Scarlsonj lif->lif_dad_wait = B_FALSE; 1215d04ccbb3Scarlsonj } 1216d04ccbb3Scarlsonj 1217d04ccbb3Scarlsonj if (unplumb) 1218d04ccbb3Scarlsonj unplumb_lif(lif); 1219d04ccbb3Scarlsonj 1220d04ccbb3Scarlsonj return (dad_wait); 1221d04ccbb3Scarlsonj } 1222d04ccbb3Scarlsonj 1223d04ccbb3Scarlsonj /* 1224d04ccbb3Scarlsonj * check_main_lif(): check the state of a main logical interface for a state 1225d04ccbb3Scarlsonj * machine. This is used only for DHCPv6. 1226d04ccbb3Scarlsonj * 1227d04ccbb3Scarlsonj * input: dhcp_smach_t *: pointer to the state machine 1228d04ccbb3Scarlsonj * const struct ifa_msghdr *: routing socket message 1229d04ccbb3Scarlsonj * int: size of routing socket message 1230d04ccbb3Scarlsonj * output: boolean_t: B_TRUE if LIF is ok. 1231d04ccbb3Scarlsonj */ 1232d04ccbb3Scarlsonj 1233d04ccbb3Scarlsonj static boolean_t 1234d04ccbb3Scarlsonj check_main_lif(dhcp_smach_t *dsmp, const struct ifa_msghdr *ifam, int msglen) 1235d04ccbb3Scarlsonj { 1236d04ccbb3Scarlsonj dhcp_lif_t *lif = dsmp->dsm_lif; 1237d04ccbb3Scarlsonj struct lifreq lifr; 1238d04ccbb3Scarlsonj 1239d04ccbb3Scarlsonj /* 1240d04ccbb3Scarlsonj * Get the real (64 bit) logical interface flags. Note that the 1241d04ccbb3Scarlsonj * routing socket message has flags, but these are just the lower 32 1242d04ccbb3Scarlsonj * bits. 1243d04ccbb3Scarlsonj */ 1244d04ccbb3Scarlsonj (void) memset(&lifr, 0, sizeof (lifr)); 1245d04ccbb3Scarlsonj (void) strlcpy(lifr.lifr_name, lif->lif_name, sizeof (lifr.lifr_name)); 1246d04ccbb3Scarlsonj if (ioctl(v6_sock_fd, SIOCGLIFFLAGS, &lifr) == -1) { 1247d04ccbb3Scarlsonj /* 1248d04ccbb3Scarlsonj * Failing to retrieve flags means that the interface is gone. 1249d04ccbb3Scarlsonj * Our state machine is now trash. 1250d04ccbb3Scarlsonj */ 1251d04ccbb3Scarlsonj if (errno == ENXIO) { 1252d04ccbb3Scarlsonj dhcpmsg(MSG_INFO, "%s has been removed; abandoning", 1253d04ccbb3Scarlsonj lif->lif_name); 1254d04ccbb3Scarlsonj } else { 1255d04ccbb3Scarlsonj dhcpmsg(MSG_ERR, 1256d04ccbb3Scarlsonj "unable to retrieve interface flags on %s", 1257d04ccbb3Scarlsonj lif->lif_name); 1258d04ccbb3Scarlsonj } 1259d04ccbb3Scarlsonj return (B_FALSE); 1260d04ccbb3Scarlsonj } else if (!check_rtm_addr(ifam, msglen, B_TRUE, &lif->lif_v6addr)) { 1261d04ccbb3Scarlsonj /* 1262d04ccbb3Scarlsonj * If the message is not about this logical interface, 1263d04ccbb3Scarlsonj * then just ignore it. 1264d04ccbb3Scarlsonj */ 1265d04ccbb3Scarlsonj return (B_TRUE); 1266d04ccbb3Scarlsonj } else if (lifr.lifr_flags & IFF_DUPLICATE) { 1267d04ccbb3Scarlsonj dhcpmsg(MSG_ERROR, "interface %s has duplicate address", 1268d04ccbb3Scarlsonj lif->lif_name); 1269d04ccbb3Scarlsonj return (B_FALSE); 1270d04ccbb3Scarlsonj } else { 1271d04ccbb3Scarlsonj return (B_TRUE); 1272d04ccbb3Scarlsonj } 1273d04ccbb3Scarlsonj } 1274d04ccbb3Scarlsonj 1275d04ccbb3Scarlsonj /* 1276d04ccbb3Scarlsonj * process_link_up_down(): check the state of a physical interface for up/down 1277d04ccbb3Scarlsonj * transitions; must go through INIT_REBOOT state if 1278d04ccbb3Scarlsonj * the link flaps. 1279d04ccbb3Scarlsonj * 1280d04ccbb3Scarlsonj * input: dhcp_pif_t *: pointer to the physical interface to check 1281d04ccbb3Scarlsonj * const struct if_msghdr *: routing socket message 1282d04ccbb3Scarlsonj * output: none 1283d04ccbb3Scarlsonj */ 1284d04ccbb3Scarlsonj 1285d04ccbb3Scarlsonj static void 1286d04ccbb3Scarlsonj process_link_up_down(dhcp_pif_t *pif, const struct if_msghdr *ifm) 1287d04ccbb3Scarlsonj { 1288d04ccbb3Scarlsonj struct lifreq lifr; 1289d04ccbb3Scarlsonj boolean_t isv6; 1290d04ccbb3Scarlsonj int fd; 1291d04ccbb3Scarlsonj 1292d04ccbb3Scarlsonj /* 1293d04ccbb3Scarlsonj * If the message implies no change of flags, then we're done; no need 1294d04ccbb3Scarlsonj * to check further. Note that if we have multiple state machines on a 1295d04ccbb3Scarlsonj * single physical interface, this test keeps us from issuing an ioctl 1296d04ccbb3Scarlsonj * for each one. 1297d04ccbb3Scarlsonj */ 1298d04ccbb3Scarlsonj if ((ifm->ifm_flags & IFF_RUNNING) && pif->pif_running || 1299d04ccbb3Scarlsonj !(ifm->ifm_flags & IFF_RUNNING) && !pif->pif_running) 1300d04ccbb3Scarlsonj return; 1301d04ccbb3Scarlsonj 1302d04ccbb3Scarlsonj /* 1303d04ccbb3Scarlsonj * We don't know what the real interface flags are, because the 1304d04ccbb3Scarlsonj * if_index number is only 16 bits; we must go ask. 1305d04ccbb3Scarlsonj */ 1306d04ccbb3Scarlsonj isv6 = pif->pif_isv6; 1307d04ccbb3Scarlsonj fd = isv6 ? v6_sock_fd : v4_sock_fd; 1308d04ccbb3Scarlsonj (void) memset(&lifr, 0, sizeof (lifr)); 1309d04ccbb3Scarlsonj (void) strlcpy(lifr.lifr_name, pif->pif_name, sizeof (lifr.lifr_name)); 1310d04ccbb3Scarlsonj 1311d04ccbb3Scarlsonj if (ioctl(fd, SIOCGLIFFLAGS, &lifr) == -1 || 1312d04ccbb3Scarlsonj !(lifr.lifr_flags & IFF_RUNNING)) { 1313d04ccbb3Scarlsonj /* 1314d04ccbb3Scarlsonj * If we've lost the interface or it has gone down, then 1315d04ccbb3Scarlsonj * nothing special to do; just turn off the running flag. 1316d04ccbb3Scarlsonj */ 1317d04ccbb3Scarlsonj pif_status(pif, B_FALSE); 1318d04ccbb3Scarlsonj } else { 1319d04ccbb3Scarlsonj /* 1320d04ccbb3Scarlsonj * Interface has come back up: go through verification process. 1321d04ccbb3Scarlsonj */ 1322d04ccbb3Scarlsonj pif_status(pif, B_TRUE); 1323d04ccbb3Scarlsonj } 132469bb4bb4Scarlsonj } 132569bb4bb4Scarlsonj 132669bb4bb4Scarlsonj /* 132769bb4bb4Scarlsonj * rtsock_event(): fetches routing socket messages and updates internal 132869bb4bb4Scarlsonj * interface state based on those messages. 132969bb4bb4Scarlsonj * 133069bb4bb4Scarlsonj * input: iu_eh_t *: unused 133169bb4bb4Scarlsonj * int: the routing socket file descriptor 133269bb4bb4Scarlsonj * (other arguments unused) 133369bb4bb4Scarlsonj * output: void 133469bb4bb4Scarlsonj */ 133569bb4bb4Scarlsonj 133669bb4bb4Scarlsonj /* ARGSUSED */ 133769bb4bb4Scarlsonj static void 133869bb4bb4Scarlsonj rtsock_event(iu_eh_t *ehp, int fd, short events, iu_event_id_t id, void *arg) 133969bb4bb4Scarlsonj { 1340d04ccbb3Scarlsonj dhcp_smach_t *dsmp, *dsmnext; 134169bb4bb4Scarlsonj union { 134269bb4bb4Scarlsonj struct ifa_msghdr ifam; 1343d04ccbb3Scarlsonj struct if_msghdr ifm; 134469bb4bb4Scarlsonj char buf[1024]; 134569bb4bb4Scarlsonj } msg; 134669bb4bb4Scarlsonj uint16_t ifindex; 134769bb4bb4Scarlsonj int msglen; 1348d04ccbb3Scarlsonj boolean_t isv6; 134969bb4bb4Scarlsonj 135069bb4bb4Scarlsonj if ((msglen = read(fd, &msg, sizeof (msg))) <= 0) 135169bb4bb4Scarlsonj return; 135269bb4bb4Scarlsonj 1353d04ccbb3Scarlsonj /* Note that the routing socket interface index is just 16 bits */ 1354d04ccbb3Scarlsonj if (msg.ifm.ifm_type == RTM_IFINFO) { 1355d04ccbb3Scarlsonj ifindex = msg.ifm.ifm_index; 1356d04ccbb3Scarlsonj isv6 = (msg.ifm.ifm_flags & IFF_IPV6) ? B_TRUE : B_FALSE; 1357d04ccbb3Scarlsonj } else if (msg.ifam.ifam_type == RTM_DELADDR || 1358d04ccbb3Scarlsonj msg.ifam.ifam_type == RTM_NEWADDR) { 1359d04ccbb3Scarlsonj ifindex = msg.ifam.ifam_index; 1360d04ccbb3Scarlsonj isv6 = is_rtm_v6(&msg.ifam, msglen); 1361d04ccbb3Scarlsonj } else { 136269bb4bb4Scarlsonj return; 1363d04ccbb3Scarlsonj } 136469bb4bb4Scarlsonj 1365d04ccbb3Scarlsonj for (dsmp = lookup_smach_by_uindex(ifindex, NULL, isv6); 1366d04ccbb3Scarlsonj dsmp != NULL; dsmp = dsmnext) { 1367d04ccbb3Scarlsonj DHCPSTATE oldstate; 1368d04ccbb3Scarlsonj boolean_t lif_finished; 1369d04ccbb3Scarlsonj boolean_t lease_removed; 1370d04ccbb3Scarlsonj dhcp_lease_t *dlp, *dlnext; 137169bb4bb4Scarlsonj 1372d04ccbb3Scarlsonj /* 1373d04ccbb3Scarlsonj * Note that script_start can call dhcp_drop directly, and 1374d04ccbb3Scarlsonj * that will do release_smach. 1375d04ccbb3Scarlsonj */ 1376d04ccbb3Scarlsonj dsmnext = lookup_smach_by_uindex(ifindex, dsmp, isv6); 1377d04ccbb3Scarlsonj oldstate = dsmp->dsm_state; 137869bb4bb4Scarlsonj 13798ff86213Scarlsonj /* 13808ff86213Scarlsonj * Ignore state machines that are currently processing drop or 13818ff86213Scarlsonj * release; there is nothing more we can do for them. 13828ff86213Scarlsonj */ 13838ff86213Scarlsonj if (dsmp->dsm_droprelease) 13848ff86213Scarlsonj continue; 13858ff86213Scarlsonj 138669bb4bb4Scarlsonj /* 1387d04ccbb3Scarlsonj * Look for link up/down notifications. These occur on a 1388d04ccbb3Scarlsonj * physical interface basis. 138969bb4bb4Scarlsonj */ 1390d04ccbb3Scarlsonj if (msg.ifm.ifm_type == RTM_IFINFO) { 1391d04ccbb3Scarlsonj process_link_up_down(dsmp->dsm_lif->lif_pif, &msg.ifm); 139269bb4bb4Scarlsonj continue; 1393d04ccbb3Scarlsonj } 139469bb4bb4Scarlsonj 139569bb4bb4Scarlsonj /* 139669bb4bb4Scarlsonj * Since we cannot trust the flags reported by the routing 139769bb4bb4Scarlsonj * socket (they're just 32 bits -- and thus never include 139869bb4bb4Scarlsonj * IFF_DUPLICATE), and we can't trust the ifindex (it's only 16 139969bb4bb4Scarlsonj * bits and also doesn't reflect the alias in use), we get 140069bb4bb4Scarlsonj * flags on all matching interfaces, and go by that. 140169bb4bb4Scarlsonj */ 1402d04ccbb3Scarlsonj lif_finished = B_FALSE; 1403d04ccbb3Scarlsonj lease_removed = B_FALSE; 1404d04ccbb3Scarlsonj for (dlp = dsmp->dsm_leases; dlp != NULL; dlp = dlnext) { 1405d04ccbb3Scarlsonj dhcp_lif_t *lif, *lifnext; 1406d04ccbb3Scarlsonj uint_t nlifs = dlp->dl_nlifs; 1407d04ccbb3Scarlsonj 1408d04ccbb3Scarlsonj dlnext = dlp->dl_next; 1409d04ccbb3Scarlsonj for (lif = dlp->dl_lifs; lif != NULL && nlifs > 0; 1410d04ccbb3Scarlsonj lif = lifnext, nlifs--) { 1411d04ccbb3Scarlsonj lifnext = lif->lif_next; 1412d04ccbb3Scarlsonj if (check_lif(lif, &msg.ifam, msglen)) { 1413d04ccbb3Scarlsonj dsmp->dsm_lif_wait--; 1414d04ccbb3Scarlsonj lif_finished = B_TRUE; 1415d04ccbb3Scarlsonj } 1416d04ccbb3Scarlsonj } 1417d04ccbb3Scarlsonj if (dlp->dl_nlifs == 0) { 1418d04ccbb3Scarlsonj remove_lease(dlp); 1419d04ccbb3Scarlsonj lease_removed = B_TRUE; 1420dc041e83Scarlsonj } 142169bb4bb4Scarlsonj } 142269bb4bb4Scarlsonj 1423d04ccbb3Scarlsonj if ((isv6 && !check_main_lif(dsmp, &msg.ifam, msglen)) || 1424d04ccbb3Scarlsonj (!isv6 && !verify_lif(dsmp->dsm_lif))) { 14258ff86213Scarlsonj dsmp->dsm_droprelease = B_TRUE; 14268ff86213Scarlsonj (void) script_start(dsmp, isv6 ? EVENT_DROP6 : 14278ff86213Scarlsonj EVENT_DROP, dhcp_drop, NULL, NULL); 1428d04ccbb3Scarlsonj continue; 142969bb4bb4Scarlsonj } 143069bb4bb4Scarlsonj 143169bb4bb4Scarlsonj /* 1432d04ccbb3Scarlsonj * Ignore this state machine if nothing interesting has 1433d04ccbb3Scarlsonj * happened. 1434d04ccbb3Scarlsonj */ 1435d04ccbb3Scarlsonj if (!lif_finished && dsmp->dsm_lif_down == 0 && 1436d04ccbb3Scarlsonj (dsmp->dsm_leases != NULL || !lease_removed)) 1437d04ccbb3Scarlsonj continue; 1438d04ccbb3Scarlsonj 1439d04ccbb3Scarlsonj /* 1440d04ccbb3Scarlsonj * If we're still waiting for DAD to complete on some of the 1441d04ccbb3Scarlsonj * configured LIFs, then don't send a response. 144269bb4bb4Scarlsonj */ 1443d04ccbb3Scarlsonj if (dsmp->dsm_lif_wait != 0) { 1444d04ccbb3Scarlsonj dhcpmsg(MSG_VERBOSE, "rtsock_event: %s still has %d " 1445d04ccbb3Scarlsonj "LIFs waiting on DAD", dsmp->dsm_name, 1446d04ccbb3Scarlsonj dsmp->dsm_lif_wait); 1447d04ccbb3Scarlsonj continue; 1448d04ccbb3Scarlsonj } 144969bb4bb4Scarlsonj 1450d04ccbb3Scarlsonj /* 1451d04ccbb3Scarlsonj * If we have some failed LIFs, then handle them now. We'll 1452d04ccbb3Scarlsonj * remove them from the list. Any leases that become empty are 1453d04ccbb3Scarlsonj * also removed as part of the decline-generation process. 1454d04ccbb3Scarlsonj */ 1455e704a8f2Smeem if (dsmp->dsm_lif_down != 0) 1456d04ccbb3Scarlsonj send_declines(dsmp); 145769bb4bb4Scarlsonj 1458d04ccbb3Scarlsonj if (dsmp->dsm_leases == NULL) { 1459d04ccbb3Scarlsonj dsmp->dsm_bad_offers++; 1460d04ccbb3Scarlsonj /* 1461d04ccbb3Scarlsonj * For DHCPv6, we'll process the restart once we're 1462d04ccbb3Scarlsonj * done sending Decline messages, because these are 1463d04ccbb3Scarlsonj * supposed to be acknowledged. With DHCPv4, there's 1464d04ccbb3Scarlsonj * no acknowledgment for a DECLINE, so after sending 1465d04ccbb3Scarlsonj * it, we just restart right away. 1466d04ccbb3Scarlsonj */ 1467d04ccbb3Scarlsonj if (!dsmp->dsm_isv6) { 1468d04ccbb3Scarlsonj dhcpmsg(MSG_VERBOSE, "rtsock_event: %s has no " 1469906cb642Scarlsonj "LIFs left", dsmp->dsm_name); 1470d04ccbb3Scarlsonj dhcp_restart(dsmp); 1471d04ccbb3Scarlsonj } 1472d04ccbb3Scarlsonj } else { 1473d04ccbb3Scarlsonj /* 1474d04ccbb3Scarlsonj * If we're now up on at least some of the leases and 1475d04ccbb3Scarlsonj * we were waiting for that, then kick off the rest of 1476d04ccbb3Scarlsonj * configuration. Lease validation and DAD are done. 1477d04ccbb3Scarlsonj */ 1478d04ccbb3Scarlsonj dhcpmsg(MSG_VERBOSE, "rtsock_event: all LIFs verified " 1479d04ccbb3Scarlsonj "on %s in %s state", dsmp->dsm_name, 1480d04ccbb3Scarlsonj dhcp_state_to_string(oldstate)); 1481d04ccbb3Scarlsonj if (oldstate == PRE_BOUND || 1482d04ccbb3Scarlsonj oldstate == ADOPTING) 1483d04ccbb3Scarlsonj dhcp_bound_complete(dsmp); 1484d04ccbb3Scarlsonj if (oldstate == ADOPTING) 1485d04ccbb3Scarlsonj dhcp_adopt_complete(dsmp); 1486d04ccbb3Scarlsonj } 148769bb4bb4Scarlsonj } 148869bb4bb4Scarlsonj } 1489d04ccbb3Scarlsonj 1490d04ccbb3Scarlsonj /* 1491d04ccbb3Scarlsonj * check_cmd_allowed(): check whether the requested command is allowed in the 1492d04ccbb3Scarlsonj * state specified. 1493d04ccbb3Scarlsonj * 1494d04ccbb3Scarlsonj * input: DHCPSTATE: current state 1495d04ccbb3Scarlsonj * dhcp_ipc_type_t: requested command 1496d04ccbb3Scarlsonj * output: boolean_t: B_TRUE if command is allowed in this state 1497d04ccbb3Scarlsonj */ 1498d04ccbb3Scarlsonj 1499d04ccbb3Scarlsonj boolean_t 1500d04ccbb3Scarlsonj check_cmd_allowed(DHCPSTATE state, dhcp_ipc_type_t cmd) 1501d04ccbb3Scarlsonj { 1502d04ccbb3Scarlsonj return (ipc_cmd_allowed[state][cmd] != 0); 1503d04ccbb3Scarlsonj } 15046cefaae1SJack Meng 15056cefaae1SJack Meng static boolean_t 15066cefaae1SJack Meng is_iscsi_active(void) 15076cefaae1SJack Meng { 1508*3644994cSmeem int fd; 1509*3644994cSmeem int active = 0; 15106cefaae1SJack Meng 1511*3644994cSmeem if ((fd = open(ISCSI_DRIVER_DEVCTL, O_RDONLY)) != -1) { 1512*3644994cSmeem if (ioctl(fd, ISCSI_IS_ACTIVE, &active) != 0) 1513*3644994cSmeem active = 0; 1514*3644994cSmeem (void) close(fd); 15156cefaae1SJack Meng } 15166cefaae1SJack Meng 1517*3644994cSmeem return (active != 0); 15186cefaae1SJack Meng } 1519