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