xref: /titanic_41/usr/src/cmd/cmd-inet/lib/nwamd/ncu_ip.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 /*
23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include <arpa/inet.h>
27 #include <assert.h>
28 #include <dhcpagent_ipc.h>
29 #include <dhcp_inittab.h>
30 #include <dhcp_symbol.h>
31 #include <dhcpagent_util.h>
32 #include <errno.h>
33 #include <execinfo.h>
34 #include <libnwam.h>
35 #include <stdlib.h>
36 #include <strings.h>
37 #include <ucontext.h>
38 #include <unistd.h>
39 #include <libscf.h>
40 
41 #include "conditions.h"
42 #include "events.h"
43 #include "ncp.h"
44 #include "ncu.h"
45 #include "objects.h"
46 #include "util.h"
47 
48 /*
49  * ncu_ip.c - contains routines that are IP interface-specific for NCUs.
50  */
51 
52 #define	STATELESS_RUNNING	(IFF_RUNNING | IFF_UP | IFF_ADDRCONF)
53 #define	DHCP_RUNNING		(IFF_RUNNING | IFF_UP | IFF_DHCPRUNNING)
54 
55 static void nwamd_dhcp(const char *, ipadm_addrobj_t, dhcp_ipc_type_t);
56 static void nwamd_down_interface(const char *, ipadm_addr_type_t, const char *);
57 static boolean_t stateless_running(const nwamd_ncu_t *);
58 
59 /*
60  * Given a sockaddr representation of an IPv4 or IPv6 address returns the
61  * string representation. Note that 'sockaddr' should point at the correct
62  * sockaddr structure for the address family (sockaddr_in for AF_INET or
63  * sockaddr_in6 for AF_INET6) or alternatively at a sockaddr_storage
64  * structure.
65  */
66 static const char *
nwamd_sockaddr2str(const struct sockaddr * addr,char * str,size_t len)67 nwamd_sockaddr2str(const struct sockaddr *addr, char *str, size_t len)
68 {
69 	struct sockaddr_in *sin;
70 	struct sockaddr_in6 *sin6;
71 	const char *straddr;
72 
73 	if (addr == NULL)
74 		return (NULL);
75 
76 	if (addr->sa_family == AF_INET) {
77 		/* LINTED E_BAD_PTR_CAST_ALIGN */
78 		sin = (struct sockaddr_in *)addr;
79 		straddr = inet_ntop(AF_INET, (void *)&sin->sin_addr, str, len);
80 	} else if (addr->sa_family == AF_INET6) {
81 		/* LINTED E_BAD_PTR_CAST_ALIGN */
82 		sin6 = (struct sockaddr_in6 *)addr;
83 		straddr = inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, str,
84 		    len);
85 	} else {
86 		errno = EINVAL;
87 		return (NULL);
88 	}
89 	return (straddr != NULL ? str : NULL);
90 }
91 
92 void
nwamd_propogate_link_up_down_to_ip(const char * linkname,boolean_t up)93 nwamd_propogate_link_up_down_to_ip(const char *linkname, boolean_t up)
94 {
95 	nwamd_object_t ip_ncu = nwamd_ncu_object_find(NWAM_NCU_TYPE_INTERFACE,
96 	    linkname);
97 	nwamd_ncu_t *ncu;
98 
99 	if (ip_ncu == NULL) {
100 		nlog(LOG_DEBUG, "nwamd_propogate_link_up_down_to_ip: no IP NCU "
101 		    "for link %s, cannot propogate %s event", linkname,
102 		    up ? "up" : "down");
103 		return;
104 	}
105 	ncu = ip_ncu->nwamd_object_data;
106 
107 	if (ncu->ncu_enabled) {
108 		if (ip_ncu->nwamd_object_aux_state ==
109 		    NWAM_AUX_STATE_UNINITIALIZED) {
110 			nlog(LOG_DEBUG,
111 			    "nwamd_propogate_link_up_down_to_ip: will not "
112 			    "propogate link %s event as IP NCU %s is being "
113 			    "removed", up ? "up" : "down", linkname);
114 		} else {
115 			nlog(LOG_DEBUG,
116 			    "nwamd_propogate_link_up_down_to_ip: propogating "
117 			    "link %s event to interface %s",
118 			    up ? "up" : "down", linkname);
119 			nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
120 			    ip_ncu->nwamd_object_name,
121 			    up ?
122 			    NWAM_STATE_OFFLINE_TO_ONLINE :
123 			    NWAM_STATE_ONLINE_TO_OFFLINE,
124 			    up ? NWAM_AUX_STATE_INITIALIZED :
125 			    NWAM_AUX_STATE_CONDITIONS_NOT_MET);
126 		}
127 	} else {
128 		nlog(LOG_DEBUG,
129 		    "nwamd_propogate_link_up_down_to_ip: not propogating "
130 		    "link %s event to interface %s, IP NCU is disabled",
131 		    up ? "up" : "down", linkname);
132 	}
133 	nwamd_object_release(ip_ncu);
134 }
135 
136 /*
137  * Returns the value associated with the given symbol for the given
138  * interface.  The interface may be NULL, in which case the primary
139  * interface is used.
140  * This function substitutes the need to call dhcpinfo(1), thus it is
141  * very similar to the implementation of dhcpinfo(1).
142  * When multiple values need to be returned (e.g., nameservers), they
143  * are separated by a space ' '.
144  */
145 char *
nwamd_get_dhcpinfo_data(const char * sym_name,char * ifname)146 nwamd_get_dhcpinfo_data(const char *sym_name, char *ifname)
147 {
148 	dhcp_symbol_t *entry;
149 	dhcp_optnum_t optnum;
150 	dhcp_ipc_request_t *request;
151 	dhcp_ipc_reply_t *reply;
152 	DHCP_OPT *opt;
153 	size_t opt_len;
154 	char *value; /* return value */
155 	int err;
156 	char errmsg[LINE_MAX];
157 
158 	/* if interface is not given, change it to empty string */
159 	if (ifname == NULL)
160 		ifname = "";
161 
162 	/* find code and category in dhcp_inittab(4) */
163 	entry = inittab_getbyname(ITAB_CAT_SITE | ITAB_CAT_STANDARD |
164 	    ITAB_CAT_VENDOR | ITAB_CAT_FIELD, ITAB_CONS_INFO, sym_name);
165 
166 	if (entry == NULL) {
167 		(void) snprintf(errmsg, LINE_MAX, "unknown identifier: %s",
168 		    sym_name);
169 		goto fail;
170 	}
171 
172 	/* allocate request */
173 	optnum.code = entry->ds_code;
174 	optnum.category = entry->ds_category;
175 	optnum.size = entry->ds_max * inittab_type_to_size(entry);
176 	request = dhcp_ipc_alloc_request(DHCP_GET_TAG, ifname, &optnum,
177 	    sizeof (dhcp_optnum_t), DHCP_TYPE_OPTNUM);
178 	if (request == NULL) {
179 		(void) snprintf(errmsg, LINE_MAX, "failed dhcp alloc request");
180 		goto fail;
181 	}
182 
183 	/* make the request */
184 	err = dhcp_ipc_make_request(request, &reply, DHCP_IPC_WAIT_DEFAULT);
185 	if (err != 0 || reply->return_code != 0) {
186 		(void) snprintf(errmsg, LINE_MAX, "%s",
187 		    dhcp_ipc_strerror(err == 0 ? reply->return_code : err));
188 	}
189 
190 	/* get data from the reply */
191 	opt = dhcp_ipc_get_data(reply, &opt_len, NULL);
192 	if (opt_len == 0) {
193 		(void) snprintf(errmsg, LINE_MAX, "invalid data");
194 		goto fail;
195 	}
196 
197 	/* check protocol error */
198 	if (opt_len < 2 || (opt_len -2 != opt->len)) {
199 		(void) snprintf(errmsg, LINE_MAX, "data length mismatch");
200 		goto fail;
201 	}
202 	opt_len -= 2;
203 
204 	/* decode the data into ascii */
205 	value = inittab_decode(entry, opt->value, opt_len, B_TRUE);
206 	if (value == NULL) {
207 		(void) snprintf(errmsg, LINE_MAX, "cannot decode reply");
208 		goto fail;
209 	}
210 
211 	free(request);
212 	free(reply);
213 	return (value);
214 
215 fail:
216 	nlog(LOG_DEBUG, "get_dhcpinfo_data() failed: %s", errmsg);
217 	free(request);
218 	free(reply);
219 	return (NULL);
220 }
221 
222 void
nwamd_add_default_routes(nwamd_ncu_t * ncu)223 nwamd_add_default_routes(nwamd_ncu_t *ncu)
224 {
225 	nwamd_if_t *nif = &ncu->ncu_if;
226 	char str[INET6_ADDRSTRLEN];
227 
228 	if (nif->nwamd_if_ipv4 && nif->nwamd_if_ipv4_default_route_set) {
229 		struct sockaddr_in v4dest, v4mask;
230 
231 		v4dest.sin_addr.s_addr = htonl(INADDR_ANY);
232 		v4dest.sin_family = AF_INET;
233 
234 		v4mask.sin_addr.s_addr = 0;
235 		v4mask.sin_family = AF_INET;
236 
237 		nlog(LOG_DEBUG, "nwamd_add_default_routes: adding default "
238 		    "route %s", nwamd_sockaddr2str((struct sockaddr *)
239 		    &nif->nwamd_if_ipv4_default_route, str,
240 		    sizeof (str)));
241 		nwamd_add_route((struct sockaddr *)&v4dest,
242 		    (struct sockaddr *)&v4mask,
243 		    (struct sockaddr *)&nif->nwamd_if_ipv4_default_route,
244 		    ncu->ncu_name);
245 	}
246 
247 	if (nif->nwamd_if_ipv6 && nif->nwamd_if_ipv6_default_route_set) {
248 		struct sockaddr_in6 v6dest, v6mask;
249 
250 		(void) bzero(&v6dest, sizeof (struct sockaddr_in6));
251 		v6dest.sin6_family = AF_INET6;
252 
253 		(void) bzero(&v6mask, sizeof (struct sockaddr_in6));
254 		v6mask.sin6_family = AF_INET6;
255 
256 		nlog(LOG_DEBUG, "nwamd_add_default_routes: adding default "
257 		    "route %s", nwamd_sockaddr2str((struct sockaddr *)
258 		    &nif->nwamd_if_ipv6_default_route, str,
259 		    sizeof (str)));
260 		nwamd_add_route((struct sockaddr *)&v6dest,
261 		    (struct sockaddr *)&v6mask,
262 		    (struct sockaddr *)&nif->nwamd_if_ipv6_default_route,
263 		    ncu->ncu_name);
264 	}
265 }
266 
267 /*
268  * Returns the nwamd_if_address structure for the given static address,
269  * NULL if not found.
270  */
271 static struct nwamd_if_address *
find_static_address(const struct sockaddr_storage * addr,const nwamd_ncu_t * ncu)272 find_static_address(const struct sockaddr_storage *addr, const nwamd_ncu_t *ncu)
273 {
274 	struct nwamd_if_address *nifap, *nifa = ncu->ncu_if.nwamd_if_list;
275 	struct sockaddr_storage saddr;
276 	char str[INET6_ADDRSTRLEN];
277 
278 	nlog(LOG_DEBUG, "find_static_address: %s",
279 	    nwamd_sockaddr2str((struct sockaddr *)addr, str, sizeof (str)));
280 	for (nifap = nifa; nifap != NULL; nifap = nifap->next) {
281 		if (nifap->ipaddr_atype != IPADM_ADDR_STATIC ||
282 		    ipadm_get_addr(nifap->ipaddr, &saddr) != IPADM_SUCCESS)
283 			continue;
284 
285 		if (sockaddrcmp(addr, &saddr))
286 			return (nifap);
287 	}
288 	return (NULL);
289 }
290 
291 /*
292  * Returns the nwamd_if_address structure representing the non-static address
293  * in the NCU.  For IPv6, both stateless and stateful (DHCPv6) share the same
294  * nwamd_if_address.  Will only return the nwamd_if_address if the relevant
295  * address is configured (v4 DHCP, v6 either stateless or stateless) for the
296  * NCU.  Returns NULL if the structure is not found.
297  */
298 static struct nwamd_if_address *
find_nonstatic_address(const nwamd_ncu_t * ncu,sa_family_t family)299 find_nonstatic_address(const nwamd_ncu_t *ncu, sa_family_t family)
300 {
301 	struct nwamd_if_address *nifap, *nifa = ncu->ncu_if.nwamd_if_list;
302 	const nwamd_if_t *u_if = &ncu->ncu_if;
303 
304 	nlog(LOG_DEBUG, "find_nonstatic_address for %s %s",
305 	    (family == AF_INET ? "IPv4" : "IPv6"),  ncu->ncu_name);
306 	for (nifap = nifa; nifap != NULL; nifap = nifap->next) {
307 		if (nifap->ipaddr_atype == IPADM_ADDR_STATIC)
308 			continue;
309 
310 		if (family == AF_INET) {
311 			if (nifap->ipaddr_atype == IPADM_ADDR_DHCP &&
312 			    u_if->nwamd_if_dhcp_requested)
313 				return (nifap);
314 		} else if (family == AF_INET6) {
315 			if (nifap->ipaddr_atype == IPADM_ADDR_IPV6_ADDRCONF &&
316 			    (u_if->nwamd_if_stateful_requested ||
317 			    u_if->nwamd_if_stateless_requested))
318 				return (nifap);
319 		}
320 	}
321 	return (NULL);
322 }
323 
324 /*
325  * Returns the nwamd_if_address structure that configured the given address,
326  * NULL if not found.
327  */
328 static struct nwamd_if_address *
find_configured_address(const struct sockaddr_storage * addr,const nwamd_ncu_t * ncu)329 find_configured_address(const struct sockaddr_storage *addr,
330     const nwamd_ncu_t *ncu)
331 {
332 	struct nwamd_if_address *nifap, *nifa = ncu->ncu_if.nwamd_if_list;
333 	char str[INET6_ADDRSTRLEN];
334 
335 	nlog(LOG_DEBUG, "find_configured_address: %s",
336 	    nwamd_sockaddr2str((struct sockaddr *)addr, str, sizeof (str)));
337 	for (nifap = nifa; nifap != NULL; nifap = nifap->next) {
338 		if (sockaddrcmp(addr, &nifap->conf_addr) ||
339 		    sockaddrcmp(addr, &nifap->conf_stateless_addr))
340 			return (nifap);
341 	}
342 	return (NULL);
343 }
344 
345 /*
346  * Are one or more static addresses configured?
347  */
348 boolean_t
nwamd_static_addresses_configured(nwamd_ncu_t * ncu,sa_family_t family)349 nwamd_static_addresses_configured(nwamd_ncu_t *ncu, sa_family_t family)
350 {
351 	struct nwamd_if_address *n;
352 
353 	for (n = ncu->ncu_if.nwamd_if_list; n != NULL; n = n->next) {
354 		if (n->ipaddr_atype != IPADM_ADDR_STATIC)
355 			continue;
356 		if ((family == AF_UNSPEC || family == n->family) &&
357 		    n->configured)
358 			return (B_TRUE);
359 	}
360 	nlog(LOG_DEBUG, "no static addresses configured for %s", ncu->ncu_name);
361 	return (B_FALSE);
362 }
363 
364 /*
365  * Is DHCP probably managing an address on this index.  We decide that it is
366  * probably managing an address if there is an interface with IFF_DHCP set
367  * that isn't in our set of static addresses.  Note that IFF_DHCP gets set
368  * on static addresses when we do a dhcp inform and if that list has changed
369  * recently then the result of this function could be erronous.
370  */
371 boolean_t
nwamd_dhcp_managing(int protocol,nwamd_ncu_t * ncu)372 nwamd_dhcp_managing(int protocol, nwamd_ncu_t *ncu)
373 {
374 	struct sockaddr_storage addr;
375 	uint64_t flags;
376 	boolean_t rv = B_FALSE;
377 	ipadm_addr_info_t *addrinfo, *a;
378 	ipadm_status_t ipstatus;
379 
380 	if ((ipstatus = ipadm_addr_info(ipadm_handle, ncu->ncu_name, &addrinfo,
381 	    0, 0)) != IPADM_SUCCESS) {
382 		nlog(LOG_ERR, "nwamd_dhcp_managing: "
383 		    "ipadm_addr_info failed for %s: %s",
384 		    ncu->ncu_name, ipadm_status2str(ipstatus));
385 		return (B_FALSE);
386 	}
387 
388 	for (a = addrinfo; a != NULL; a = IA_NEXT(a)) {
389 		/*
390 		 * WARNING: This memcpy() assumes knowledge of the
391 		 * implementation of getifaddrs() and that it always
392 		 * uses sockaddr_storage as the backing store for
393 		 * address information, thus making it possible to
394 		 * copy the entire structure rather than do it on
395 		 * the size of the sockaddr according to family.
396 		 * This assumption is made elsewhere in this file.
397 		 */
398 		(void) memcpy(&addr, a->ia_ifa.ifa_addr, sizeof (addr));
399 
400 		/* is this address an expected static one? */
401 		if (find_static_address(&addr, ncu) != NULL)
402 			continue;
403 
404 		/*
405 		 * For IPv4, DHCPRUNNING flag is set when dhcpagent is in
406 		 * the process of getting an address, but doesn't have one
407 		 * yet (interface has 0.0.0.0).  For IPv6, DHCPRUNNING flag
408 		 * is set on the link-local address if trying to get a
409 		 * stateful address.  In both cases, consider the interface
410 		 * as not being managed by DHCP and skip checking of flags.
411 		 */
412 		if ((protocol == AF_INET &&
413 		    ((struct sockaddr_in *)&addr)->sin_addr.s_addr ==
414 		    INADDR_ANY) ||
415 		    (protocol == AF_INET6 &&
416 		    IN6_IS_ADDR_LINKLOCAL(
417 		    &((struct sockaddr_in6 *)&addr)->sin6_addr))) {
418 			continue;
419 		}
420 
421 		flags = a->ia_ifa.ifa_flags;
422 		if (flags & IFF_DHCPRUNNING) {
423 			/*
424 			 * If we get here we have an address that has the
425 			 * DHCP flag set and isn't an expected static address.
426 			 */
427 			rv = B_TRUE;
428 			break;
429 		}
430 	}
431 
432 	ipadm_free_addr_info(addrinfo);
433 	return (rv);
434 }
435 
436 /*
437  * Return B_TRUE if IPv4 is requested in the given NCU.
438  */
439 static boolean_t
nwamd_v4_requested(nwamd_ncu_t * ncu)440 nwamd_v4_requested(nwamd_ncu_t *ncu)
441 {
442 	boolean_t anyv4_requested;
443 	nwamd_if_t *u_if;
444 
445 	anyv4_requested = B_FALSE;
446 	u_if = &ncu->ncu_if;
447 	if (u_if->nwamd_if_dhcp_requested) {
448 		anyv4_requested = B_TRUE;
449 	} else {
450 		struct nwamd_if_address *n;
451 
452 		for (n = u_if->nwamd_if_list; n != NULL; n = n->next) {
453 			if (n->family == AF_INET &&
454 			    n->ipaddr_atype == IPADM_ADDR_STATIC)
455 				break;
456 		}
457 		if (n != NULL)
458 			anyv4_requested = B_TRUE;
459 	}
460 
461 	return (anyv4_requested);
462 }
463 
464 /*
465  * Returns B_TRUE if IPv6 is requested in the given NCU.
466  */
467 static boolean_t
nwamd_v6_requested(nwamd_ncu_t * ncu)468 nwamd_v6_requested(nwamd_ncu_t *ncu)
469 {
470 	boolean_t anyv6_requested;
471 	nwamd_if_t *u_if;
472 
473 	anyv6_requested = B_FALSE;
474 	u_if = &ncu->ncu_if;
475 	if (u_if->nwamd_if_stateful_requested ||
476 	    u_if->nwamd_if_stateless_requested) {
477 		anyv6_requested = B_TRUE;
478 	} else {
479 		struct nwamd_if_address *n;
480 
481 		for (n = u_if->nwamd_if_list; n != NULL; n = n->next) {
482 			if (n->family == AF_INET6 &&
483 			    n->ipaddr_atype == IPADM_ADDR_STATIC)
484 				break;
485 		}
486 		if (n != NULL)
487 			anyv6_requested = B_TRUE;
488 	}
489 
490 	return (anyv6_requested);
491 }
492 
493 /*
494  * Bring up the ncu if we have the right combination of requested configuration
495  * and actual configuration and up is true, or bring down the ncu if no
496  * addresses are configured, and up is false.
497  */
498 static void
interface_ncu_up_down(nwamd_ncu_t * ncu,boolean_t up)499 interface_ncu_up_down(nwamd_ncu_t *ncu, boolean_t up)
500 {
501 	boolean_t ncu_online;
502 	char *name;
503 
504 	assert(ncu->ncu_type == NWAM_NCU_TYPE_INTERFACE);
505 
506 	/*
507 	 * If V4 with or without V6 is configured then one of its interfaces
508 	 * needs to be up for the ncu to come online.  If only V6 is requested
509 	 * then one of its interfaces needs to be up for the ncu to come online.
510 	 */
511 	ncu_online = B_FALSE;
512 	if (nwamd_v4_requested(ncu)) {
513 		if (nwamd_dhcp_managing(AF_INET, ncu) ||
514 		    nwamd_static_addresses_configured(ncu, AF_INET))
515 			ncu_online = B_TRUE;
516 	} else if (nwamd_v6_requested(ncu)) {
517 		if ((nwamd_dhcp_managing(AF_INET6, ncu) ||
518 		    stateless_running(ncu) ||
519 		    nwamd_static_addresses_configured(ncu, AF_INET6)))
520 			ncu_online = B_TRUE;
521 	}
522 
523 	if (nwam_ncu_name_to_typed_name(ncu->ncu_name, ncu->ncu_type, &name) !=
524 	    NWAM_SUCCESS) {
525 		nlog(LOG_DEBUG, "interface_ncu_up_down: "
526 		    "nwam_ncu_name_to_typed_name failed");
527 		return;
528 	}
529 	if (ncu_online && up) {
530 		nlog(LOG_DEBUG, "interface_ncu_up_down: "
531 		    "bringing %s up", name);
532 		nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU, name,
533 		    NWAM_STATE_OFFLINE_TO_ONLINE, NWAM_AUX_STATE_UP);
534 	} else if (!ncu_online && !up) {
535 		nlog(LOG_DEBUG, "interface_ncu_up_down: "
536 		    "bringing %s down", name);
537 		nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU, name,
538 		    NWAM_STATE_ONLINE_TO_OFFLINE,
539 		    NWAM_AUX_STATE_DOWN);
540 	}
541 
542 	free(name);
543 }
544 
545 static void
interface_ncu_up(nwamd_ncu_t * ncu)546 interface_ncu_up(nwamd_ncu_t *ncu)
547 {
548 	interface_ncu_up_down(ncu, B_TRUE);
549 }
550 
551 static void
interface_ncu_down(nwamd_ncu_t * ncu)552 interface_ncu_down(nwamd_ncu_t *ncu)
553 {
554 	interface_ncu_up_down(ncu, B_FALSE);
555 }
556 
557 static boolean_t
stateless_running(const nwamd_ncu_t * ncu)558 stateless_running(const nwamd_ncu_t *ncu)
559 {
560 	ipadm_addr_info_t *ainfo, *ainfop;
561 	ipadm_status_t ipstatus;
562 	boolean_t rv = B_FALSE;
563 	uint64_t flags;
564 
565 	if ((ipstatus = ipadm_addr_info(ipadm_handle, ncu->ncu_name, &ainfo,
566 	    0, 0)) != IPADM_SUCCESS) {
567 		nlog(LOG_ERR, "stateless_running: "
568 		    "ipadm_addr_info failed for %s: %s",
569 		    ncu->ncu_name, ipadm_status2str(ipstatus));
570 		return (B_FALSE);
571 	}
572 
573 	for (ainfop = ainfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
574 		if (ainfop->ia_ifa.ifa_addr->sa_family != AF_INET6)
575 			continue;
576 		flags = ainfop->ia_ifa.ifa_flags;
577 		if (flags & STATELESS_RUNNING) {
578 			rv = B_TRUE;
579 			break;
580 		}
581 	}
582 	ipadm_free_addr_info(ainfo);
583 	return (rv);
584 }
585 
586 /*
587  * Returns the addrinfo associated with the given address.  There is always
588  * only one addrinfo for each address.
589  */
590 static boolean_t
addrinfo_for_addr(const struct sockaddr_storage * caddr,const char * ifname,ipadm_addr_info_t ** ainfo)591 addrinfo_for_addr(const struct sockaddr_storage *caddr, const char *ifname,
592     ipadm_addr_info_t **ainfo)
593 {
594 	ipadm_addr_info_t *addrinfo, *ainfop, *last = NULL;
595 	ipadm_status_t ipstatus;
596 
597 	ipstatus = ipadm_addr_info(ipadm_handle, ifname, &addrinfo, 0, 0);
598 	if (ipstatus != IPADM_SUCCESS) {
599 		nlog(LOG_INFO, "addrinfo_for_addr: "
600 		    "ipadm_addr_info failed for %s: %s",
601 		    ifname, ipadm_status2str(ipstatus));
602 		return (B_FALSE);
603 	}
604 
605 	*ainfo = NULL;
606 	for (ainfop = addrinfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
607 		struct sockaddr_storage addr;
608 
609 		(void) memcpy(&addr, ainfop->ia_ifa.ifa_addr, sizeof (addr));
610 		/*
611 		 * If addresses match, rearrange pointers so that addrinfo
612 		 * does not contain a, and return a.
613 		 */
614 		if (sockaddrcmp(&addr, caddr)) {
615 			if (last != NULL)
616 				last->ia_ifa.ifa_next = ainfop->ia_ifa.ifa_next;
617 			else
618 				addrinfo = IA_NEXT(ainfop);
619 
620 			ainfop->ia_ifa.ifa_next = NULL;
621 			*ainfo = ainfop;
622 			break;
623 		}
624 		last = ainfop;
625 	}
626 	ipadm_free_addr_info(addrinfo);
627 	return (*ainfo == NULL ? B_FALSE : B_TRUE);
628 }
629 
630 /*
631  * Returns B_TRUE if the addrinfo associated with the given ipaddr using its
632  * aobjname is found.  An addrinfo list is created and returned in ainfo.
633  * Stateless and stateful IPv6 addrinfo have the same aobjname, thus the need
634  * to create a list of addrinfo.
635  */
636 static boolean_t
addrinfo_for_ipaddr(ipadm_addrobj_t ipaddr,const char * ifname,ipadm_addr_info_t ** ainfo)637 addrinfo_for_ipaddr(ipadm_addrobj_t ipaddr, const char *ifname,
638     ipadm_addr_info_t **ainfo)
639 {
640 	char aobjname[IPADM_AOBJSIZ];
641 	ipadm_addr_info_t *addrinfo, *ainfop;
642 	ipadm_addr_info_t *last = NULL;
643 	ipadm_status_t ipstatus;
644 
645 	ipstatus = ipadm_get_aobjname(ipaddr, aobjname, sizeof (aobjname));
646 	if (ipstatus != IPADM_SUCCESS)
647 		return (B_FALSE);
648 
649 	ipstatus = ipadm_addr_info(ipadm_handle, ifname, &addrinfo, 0, 0);
650 	if (ipstatus != IPADM_SUCCESS) {
651 		nlog(LOG_INFO, "addrinfo_for_ipaddr: "
652 		    "ipadm_addr_info failed for %s: %s",
653 		    ifname, ipadm_status2str(ipstatus));
654 		return (B_FALSE);
655 	}
656 
657 	*ainfo = NULL;
658 	ainfop = addrinfo;
659 	while (ainfop != NULL) {
660 		/* If aobjnames match, rearrange pointers to create new list */
661 		if (strcmp(ainfop->ia_aobjname, aobjname) == 0) {
662 			ipadm_addr_info_t *match = ainfop;
663 
664 			ainfop = IA_NEXT(ainfop); /* move iterator */
665 			if (last != NULL)
666 				last->ia_ifa.ifa_next = match->ia_ifa.ifa_next;
667 			else
668 				addrinfo = ainfop;
669 			if (*ainfo == NULL)
670 				match->ia_ifa.ifa_next = NULL;
671 			else
672 				match->ia_ifa.ifa_next = &(*ainfo)->ia_ifa;
673 			*ainfo = match;
674 		} else {
675 			last = ainfop;
676 			ainfop = IA_NEXT(ainfop);
677 		}
678 	}
679 	ipadm_free_addr_info(addrinfo);
680 	return (*ainfo == NULL ? B_FALSE : B_TRUE);
681 }
682 
683 /*
684  * Add the address provided in the nwamd_if_address.  If DHCP is required,
685  * start DHCP.  If a static address is configured, create the address; then do
686  * a DHCP_INFORM (in a separate thread) to get other networking configuration
687  * parameters.  RTM_NEWADDRs - translated into IF_STATE events - will then
688  * finish the job of bringing the NCU online.
689  */
690 static boolean_t
add_ip_address(const char * ifname,const struct nwamd_if_address * nifa,boolean_t * do_inform)691 add_ip_address(const char *ifname, const struct nwamd_if_address *nifa,
692     boolean_t *do_inform)
693 {
694 	ipadm_status_t ipstatus;
695 	ipadm_addr_info_t *addrinfo = NULL;
696 	uint64_t flags;
697 
698 	if (nifa->ipaddr_atype == IPADM_ADDR_DHCP) {
699 		/*
700 		 * To make getting a DHCP address asynchronous, call
701 		 * ipadm_create_addr() in a new thread.
702 		 */
703 		nlog(LOG_DEBUG, "add_ip_address: "
704 		    "adding IPv4 DHCP address on %s", ifname);
705 		nwamd_dhcp(ifname, nifa->ipaddr, DHCP_START);
706 	} else {
707 		nlog(LOG_DEBUG, "add_ip_address: adding %s address on %s",
708 		    (nifa->ipaddr_atype == IPADM_ADDR_STATIC ?
709 		    "STATIC" : "IPv6 ADDRCONF"), ifname);
710 		if ((ipstatus = ipadm_create_addr(ipadm_handle, nifa->ipaddr,
711 		    IPADM_OPT_ACTIVE | IPADM_OPT_UP)) != IPADM_SUCCESS) {
712 			nlog(LOG_ERR, "add_ip_address: "
713 			    "ipadm_create_addr failed on %s: %s",
714 			    ifname, ipadm_status2str(ipstatus));
715 			return (B_FALSE);
716 		}
717 		/*
718 		 * When creating a static address, ipadm_create_addr() returns
719 		 * SUCCESS even if duplicate address is detected.  Retrieve
720 		 * the addrinfo to get the flags.
721 		 */
722 		if (nifa->ipaddr_atype == IPADM_ADDR_STATIC) {
723 			/*
724 			 * Since we are configuring a static address, there
725 			 * will be just *ONE* addrinfo with the aobjname in
726 			 * nifa->ipaddr.
727 			 */
728 			if (!addrinfo_for_ipaddr(nifa->ipaddr, ifname,
729 			    &addrinfo)) {
730 				nlog(LOG_ERR, "add_ip_address: "
731 				    "could not find addrinfo on %s", ifname);
732 				return (B_FALSE);
733 			}
734 
735 			flags = addrinfo->ia_ifa.ifa_flags;
736 			ipadm_free_addr_info(addrinfo);
737 			if (flags & IFF_DUPLICATE) {
738 				char *object_name;
739 				nwam_error_t err;
740 
741 				nlog(LOG_INFO, "add_ip_address: "
742 				    "duplicate address detected on %s", ifname);
743 				if ((err = nwam_ncu_name_to_typed_name(ifname,
744 				    NWAM_NCU_TYPE_INTERFACE, &object_name))
745 				    == NWAM_SUCCESS) {
746 					nwamd_object_set_state(
747 					    NWAM_OBJECT_TYPE_NCU,
748 					    object_name, NWAM_STATE_MAINTENANCE,
749 					    NWAM_AUX_STATE_IF_DUPLICATE_ADDR);
750 					free(object_name);
751 				} else {
752 					nlog(LOG_ERR, "add_ip_address: "
753 					    "could not create state event "
754 					    "for %s: %s",
755 					    ifname, nwam_strerror(err));
756 				}
757 				return (B_FALSE);
758 			}
759 			/*
760 			 * Do DHCP_INFORM using async ipadm_refresh_addr().
761 			 * Only need to do this once per interface, and we
762 			 * do *not* need to do it if we are also getting a
763 			 * dhcp lease; so we only send the INFORM if the
764 			 * passed-in flag says to, and we clear the flag
765 			 * once we've initiated the INFORM transaction.
766 			 */
767 			if (*do_inform) {
768 				nwamd_dhcp(ifname, nifa->ipaddr, DHCP_INFORM);
769 				*do_inform = B_FALSE;
770 			}
771 		}
772 	}
773 
774 	return (B_TRUE);
775 }
776 
777 /*
778  * Adds addresses for the given NCU.
779  */
780 void
nwamd_configure_interface_addresses(nwamd_ncu_t * ncu)781 nwamd_configure_interface_addresses(nwamd_ncu_t *ncu)
782 {
783 	struct nwamd_if_address *nifap, *nifa = ncu->ncu_if.nwamd_if_list;
784 	boolean_t do_inform;
785 
786 	/* only need an inform if we're not also getting a dhcp lease */
787 	do_inform = !ncu->ncu_if.nwamd_if_dhcp_requested;
788 
789 	nlog(LOG_DEBUG, "nwamd_configure_interface_addresses(%s)",
790 	    ncu->ncu_name);
791 
792 	for (nifap = nifa; nifap != NULL; nifap = nifap->next) {
793 		if (nifap->configured)
794 			continue;
795 
796 		nifap->configured = add_ip_address(ncu->ncu_name, nifap,
797 		    &do_inform);
798 	}
799 }
800 
801 /*
802  * This event tells us that an interface address has appeared or disappeared,
803  * or that the interface flags on an interface have changed.
804  */
805 void
nwamd_ncu_handle_if_state_event(nwamd_event_t event)806 nwamd_ncu_handle_if_state_event(nwamd_event_t event)
807 {
808 	nwam_event_t evm;
809 	nwamd_object_t ncu_obj;
810 	nwamd_ncu_t *ncu;
811 	nwam_state_t state;
812 	nwam_aux_state_t aux_state;
813 
814 	ncu_obj = nwamd_object_find(NWAM_OBJECT_TYPE_NCU,
815 	    event->event_object);
816 	if (ncu_obj == NULL) {
817 		nlog(LOG_INFO, "nwamd_ncu_handle_if_state_event: no object %s",
818 		    event->event_object);
819 		nwamd_event_do_not_send(event);
820 		return;
821 	}
822 	ncu = ncu_obj->nwamd_object_data;
823 	evm = event->event_msg;
824 	state = ncu_obj->nwamd_object_state;
825 	aux_state = ncu_obj->nwamd_object_aux_state;
826 
827 	nlog(LOG_DEBUG, "nwamd_ncu_handle_if_state_event: "
828 	    "if %s, state (%s, %s)", event->event_object,
829 	    nwam_state_to_string(state), nwam_aux_state_to_string(aux_state));
830 
831 	/* Ensure object is in correct state to handle IF state events */
832 	switch (state) {
833 	case NWAM_STATE_OFFLINE_TO_ONLINE:
834 		if (aux_state != NWAM_AUX_STATE_IF_WAITING_FOR_ADDR &&
835 		    aux_state != NWAM_AUX_STATE_IF_DHCP_TIMED_OUT) {
836 			nlog(LOG_DEBUG, "nwamd_ncu_handle_if_state_event: "
837 			    "if %s is in invalid aux state %s for IF_STATE "
838 			    "events", event->event_object,
839 			    nwam_aux_state_to_string(aux_state));
840 			nwamd_event_do_not_send(event);
841 			nwamd_object_release(ncu_obj);
842 			return;
843 		}
844 		break;
845 	case NWAM_STATE_ONLINE:
846 	/*
847 	 * We can get addresses from DHCP after we've taken the interface down.
848 	 * We deal with those below.
849 	 */
850 	case NWAM_STATE_ONLINE_TO_OFFLINE:
851 	case NWAM_STATE_OFFLINE:
852 		break;
853 	default:
854 		nlog(LOG_DEBUG, "nwamd_ncu_handle_if_state_event: "
855 		    "if %s is in invalid state %s for IF_STATE events",
856 		    event->event_object, nwam_state_to_string(state));
857 		nwamd_event_do_not_send(event);
858 		nwamd_object_release(ncu_obj);
859 		return;
860 	}
861 
862 	if (evm->nwe_data.nwe_if_state.nwe_addr_valid) {
863 		struct nwam_event_if_state *if_state;
864 		char addrstr[INET6_ADDRSTRLEN];
865 		boolean_t static_addr, addr_added;
866 		boolean_t v4dhcp_running, v6dhcp_running, stateless_running;
867 		ipadm_addr_info_t *ai = NULL, *addrinfo = NULL;
868 		boolean_t stateless_ai_found = B_FALSE;
869 		boolean_t stateful_ai_found = B_FALSE;
870 		struct nwamd_if_address *nifa = NULL;
871 		nwamd_if_t *u_if;
872 		struct sockaddr_storage *addr, ai_addr, *aip = NULL;
873 		ushort_t family;
874 		uint64_t flags = 0;
875 
876 		if_state = &evm->nwe_data.nwe_if_state;
877 		u_if = &ncu->ncu_if;
878 		family = if_state->nwe_addr.ss_family;
879 		addr = &if_state->nwe_addr;
880 		addr_added = if_state->nwe_addr_added;
881 
882 		nlog(LOG_DEBUG,
883 		    "nwamd_ncu_handle_if_state_event: addr %s %s",
884 		    nwamd_sockaddr2str((struct sockaddr *)addr, addrstr,
885 		    sizeof (addrstr)), addr_added ? "added" : "removed");
886 
887 		/*
888 		 * Need to get flags for this interface.  Get the addrinfo for
889 		 * the address that generated this IF_STATE event.
890 		 */
891 		if (addr_added) {
892 			/*
893 			 * Address was added.  Find the addrinfo for this
894 			 * address and the nwamd_if_address corresponding to
895 			 * this address.
896 			 */
897 			if (!addrinfo_for_addr(addr, ncu->ncu_name, &ai)) {
898 				nlog(LOG_ERR,
899 				    "nwamd_ncu_handle_if_state_event: "
900 				    "addrinfo doesn't exist for %s", addrstr);
901 				nwamd_event_do_not_send(event);
902 				goto valid_done;
903 			}
904 			addrinfo = ai;
905 			flags = addrinfo->ia_ifa.ifa_flags;
906 			(void) memcpy(&ai_addr, addrinfo->ia_ifa.ifa_addr,
907 			    sizeof (ai_addr));
908 			aip = &ai_addr;
909 
910 			if (addrinfo->ia_atype == IPADM_ADDR_IPV6_ADDRCONF ||
911 			    addrinfo->ia_atype == IPADM_ADDR_DHCP)
912 				nifa = find_nonstatic_address(ncu, family);
913 			else if (addrinfo->ia_atype == IPADM_ADDR_STATIC)
914 				nifa = find_static_address(addr, ncu);
915 
916 			/*
917 			 * If nwamd_if_address is not found, then this address
918 			 * isn't one that nwamd created.  Remove it.
919 			 */
920 			if (nifa == NULL) {
921 				nlog(LOG_ERR,
922 				    "nwamd_ncu_handle_if_state_event: "
923 				    "address %s not managed by nwam added, "
924 				    "removing it", addrstr);
925 				nwamd_down_interface(addrinfo->ia_aobjname,
926 				    addrinfo->ia_atype, ncu->ncu_name);
927 				nwamd_event_do_not_send(event);
928 				goto valid_done;
929 			}
930 
931 			/* check flags to determine how intf is configured */
932 			stateless_running = (family == AF_INET6) &&
933 			    ((flags & STATELESS_RUNNING) == STATELESS_RUNNING);
934 			v4dhcp_running = (family == AF_INET) &&
935 			    ((flags & DHCP_RUNNING) == DHCP_RUNNING);
936 			v6dhcp_running = (family == AF_INET6) &&
937 			    ((flags & DHCP_RUNNING) == DHCP_RUNNING);
938 			static_addr = (addrinfo->ia_atype == IPADM_ADDR_STATIC);
939 
940 			/* copy the configured address into nwamd_if_address */
941 			if (stateless_running) {
942 				(void) memcpy(&nifa->conf_stateless_addr,
943 				    addrinfo->ia_ifa.ifa_addr,
944 				    sizeof (struct sockaddr_storage));
945 			} else {
946 				(void) memcpy(&nifa->conf_addr,
947 				    addrinfo->ia_ifa.ifa_addr,
948 				    sizeof (struct sockaddr_storage));
949 			}
950 
951 		} else {
952 			/*
953 			 * Address was removed.  Find the nwamd_if_address
954 			 * that configured this address.
955 			 */
956 			nifa = find_configured_address(addr, ncu);
957 			if (nifa == NULL) {
958 				nlog(LOG_ERR,
959 				    "nwamd_ncu_handle_if_state_event: "
960 				    "address %s not managed by nwam removed, "
961 				    "nothing to do", addrstr);
962 				nwamd_event_do_not_send(event);
963 				goto valid_done;
964 			}
965 
966 			if (addrinfo_for_ipaddr(nifa->ipaddr, ncu->ncu_name,
967 			    &ai)) {
968 				ipadm_addr_info_t *a;
969 				for (a = ai; a != NULL; a = IA_NEXT(a)) {
970 					struct sockaddr_storage stor;
971 
972 					(void) memcpy(&stor, a->ia_ifa.ifa_addr,
973 					    sizeof (stor));
974 					/*
975 					 * Since multiple addrinfo can have
976 					 * the same ipaddr, find the one for
977 					 * the address that generated this
978 					 * state event.
979 					 */
980 					if (sockaddrcmp(addr, &stor)) {
981 						flags = a->ia_ifa.ifa_flags;
982 						(void) memcpy(&ai_addr,
983 						    a->ia_ifa.ifa_addr,
984 						    sizeof (ai_addr));
985 						aip = &ai_addr;
986 						addrinfo = a;
987 					}
988 					/*
989 					 * Stateful and stateless IPv6
990 					 * addrinfo have the same aobjname.
991 					 * Use the flags to determine which
992 					 * address is present in the system.
993 					 */
994 					if (family == AF_INET6) {
995 						stateless_ai_found =
996 						    (a->ia_ifa.ifa_flags &
997 						    STATELESS_RUNNING);
998 						stateful_ai_found =
999 						    (a->ia_ifa.ifa_flags &
1000 						    DHCP_RUNNING);
1001 					}
1002 				}
1003 			}
1004 		}
1005 
1006 		/* Set the flags in the event for listeners */
1007 		evm->nwe_data.nwe_if_state.nwe_flags = flags;
1008 
1009 		if (family == AF_INET && !addr_added) {
1010 			/*
1011 			 * Check for failure due to CR 6745448: if we get a
1012 			 * report that an address has been deleted, then check
1013 			 * for interface up, datalink down, and actual address
1014 			 * non-zero.  If that combination is seen, then this is
1015 			 * a DHCP cached lease, and we need to remove it from
1016 			 * the system, or it'll louse up the kernel routes
1017 			 * (which aren't smart enough to avoid dead
1018 			 * interfaces).
1019 			 */
1020 			if (((struct sockaddr_in *)addr)->sin_addr.s_addr
1021 			    == INADDR_ANY && aip != 0) {
1022 				struct sockaddr_in *a;
1023 				char astr[INET6_ADDRSTRLEN];
1024 				a = (struct sockaddr_in *)aip;
1025 
1026 				if ((flags & IFF_UP) &&
1027 				    !(flags & IFF_RUNNING) &&
1028 				    a->sin_addr.s_addr != INADDR_ANY) {
1029 					nlog(LOG_DEBUG,
1030 					    "nwamd_ncu_handle_if_state_event: "
1031 					    "bug workaround: clear out addr "
1032 					    "%s on %s", nwamd_sockaddr2str
1033 					    ((struct sockaddr *)a, astr,
1034 					    sizeof (astr)),
1035 					    ncu->ncu_name);
1036 					nwamd_down_interface(
1037 					    addrinfo->ia_aobjname,
1038 					    IPADM_ADDR_DHCP, ncu->ncu_name);
1039 				}
1040 				goto valid_done;
1041 			}
1042 		}
1043 
1044 		/*
1045 		 * If we received an RTM_NEWADDR and the IFF_UP flags has not
1046 		 * been set, ignore this IF_STATE event.  Once the IFF_UP flag
1047 		 * is set, we'll get another RTM_NEWADDR message.
1048 		 */
1049 		if (addr_added & !(flags & IFF_UP)) {
1050 			nlog(LOG_INFO, "nwamd_ncu_handle_if_state_event: "
1051 			    "address %s added on %s without IFF_UP flag (%x), "
1052 			    "ignoring IF_STATE event",
1053 			    addrstr, ncu->ncu_name, flags);
1054 			nwamd_event_do_not_send(event);
1055 			goto valid_done;
1056 		}
1057 
1058 		/*
1059 		 * Has the address really been removed?  Sometimes spurious
1060 		 * RTM_DELADDRs are generated, so we need to ensure that
1061 		 * the address is really gone.  If IFF_DUPLICATE is set,
1062 		 * we're getting the RTM_DELADDR due to DAD, so don't test
1063 		 * in that case.
1064 		 */
1065 		if (!addr_added && !(flags & IFF_DUPLICATE)) {
1066 			if (aip != 0 && sockaddrcmp(addr, aip)) {
1067 				nlog(LOG_INFO,
1068 				    "nwamd_ncu_handle_if_state_event: "
1069 				    "address %s is not really gone from %s, "
1070 				    "ignoring IF_STATE event",
1071 				    addrstr, ncu->ncu_name);
1072 				nwamd_event_do_not_send(event);
1073 				goto valid_done;
1074 			}
1075 		}
1076 
1077 		if (addr_added) {
1078 			/*
1079 			 * Address has been added.
1080 			 *
1081 			 * We need to make sure that we really want to keep
1082 			 * this address.  There is a race where we requested an
1083 			 * address but by the time we got here we don't really
1084 			 * want it and need to remove it.
1085 			 *
1086 			 * Once we decide we want the address adjust the ncu
1087 			 * state accordingly.  For example if this address is
1088 			 * enough move online.
1089 			 */
1090 			if (u_if->nwamd_if_dhcp_requested && v4dhcp_running) {
1091 				u_if->nwamd_if_dhcp_configured = B_TRUE;
1092 			} else if (u_if->nwamd_if_stateful_requested &&
1093 			    v6dhcp_running) {
1094 				u_if->nwamd_if_stateful_configured = B_TRUE;
1095 			} else if (u_if->nwamd_if_stateless_requested &&
1096 			    stateless_running) {
1097 				u_if->nwamd_if_stateless_configured = B_TRUE;
1098 			} else if (!static_addr) {
1099 				/*
1100 				 * This is something we didn't expect.  Remove
1101 				 * the address.
1102 				 */
1103 				nwamd_down_interface(addrinfo->ia_aobjname,
1104 				    addrinfo->ia_atype, ncu->ncu_name);
1105 				nifa->configured = B_FALSE;
1106 				goto valid_done;
1107 			}
1108 
1109 			/*
1110 			 * The address looks valid so mark configured and
1111 			 * move online if we either have a v4 address if
1112 			 * v4 is configured or a v6 address if only v6 is
1113 			 * configured.
1114 			 */
1115 			nifa->configured = B_TRUE;
1116 			if (state != NWAM_STATE_ONLINE)
1117 				interface_ncu_up(ncu);
1118 
1119 			/*
1120 			 * Refresh network/location since we may also have other
1121 			 * DHCP information.  We might have to restore it first
1122 			 * in case it is in maintenance.
1123 			 */
1124 			nlog(LOG_DEBUG, "nwamd_handle_if_state_event: "
1125 			    "refreshing %s as we may have other "
1126 			    "DHCP information", NET_LOC_FMRI);
1127 			(void) smf_restore_instance(NET_LOC_FMRI);
1128 			if (smf_refresh_instance(NET_LOC_FMRI) != 0) {
1129 				nlog(LOG_ERR,
1130 				    "nwamd_ncu_handle_if_state_"
1131 				    "event: refresh of %s "
1132 				    "failed", NET_LOC_FMRI);
1133 			}
1134 
1135 		} else if (state == NWAM_STATE_ONLINE ||
1136 		    state == NWAM_STATE_OFFLINE_TO_ONLINE) {
1137 			/*
1138 			 * Address has been removed.  Only pay attention to
1139 			 * disappearing addresses if we are online or coming
1140 			 * online.
1141 			 *
1142 			 * Undo whatever configuration is necessary.  Note
1143 			 * that this may or may not cause the NCU to go down.
1144 			 * We can get RTM_DELADDRs for duplicate addresses
1145 			 * so deal with this seperately.
1146 			 */
1147 			nifa->configured = B_FALSE;
1148 
1149 			if (!static_addr && family == AF_INET) {
1150 				u_if->nwamd_if_dhcp_configured = B_FALSE;
1151 			} else if (!static_addr && family == AF_INET6) {
1152 				/*
1153 				 * The address is already gone.  When looking
1154 				 * for the addrinfo (using aobjname in
1155 				 * ipaddr), we found addrinfo for either one
1156 				 * or both stateless and stateful.  Using the
1157 				 * flags we determined whether each was
1158 				 * configured or not.  Update the flags here
1159 				 * accordingly.
1160 				 */
1161 				u_if->nwamd_if_stateful_configured =
1162 				    stateless_ai_found;
1163 				u_if->nwamd_if_stateless_configured =
1164 				    stateful_ai_found;
1165 			}
1166 
1167 			if (flags & IFF_DUPLICATE) {
1168 				nlog(LOG_INFO,
1169 				    "nwamd_ncu_handle_if_state_event: "
1170 				    "duplicate address detected on %s",
1171 				    ncu->ncu_name);
1172 				nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
1173 				    event->event_object,
1174 				    NWAM_STATE_MAINTENANCE,
1175 				    NWAM_AUX_STATE_IF_DUPLICATE_ADDR);
1176 			} else {
1177 				interface_ncu_down(ncu);
1178 			}
1179 		}
1180 valid_done:
1181 		ipadm_free_addr_info(ai);
1182 	}
1183 	nwamd_object_release(ncu_obj);
1184 }
1185 
1186 void
nwamd_ncu_handle_if_action_event(nwamd_event_t event)1187 nwamd_ncu_handle_if_action_event(nwamd_event_t event)
1188 {
1189 	nwamd_object_t ncu_obj;
1190 
1191 	nlog(LOG_DEBUG, "if action event %s",
1192 	    event->event_object[0] == '\0' ? "n/a" : event->event_object);
1193 
1194 	ncu_obj = nwamd_object_find(NWAM_OBJECT_TYPE_NCU, event->event_object);
1195 	if (ncu_obj == NULL) {
1196 		nlog(LOG_ERR, "nwamd_ncu_handle_if_action_event: no object");
1197 		nwamd_event_do_not_send(event);
1198 		return;
1199 	}
1200 	nwamd_object_release(ncu_obj);
1201 }
1202 
1203 /*
1204  * Remove the address in the given aobjname.  IPADM_OPT_RELEASE is specified
1205  * for a DHCP address and specifies that the DHCP lease should also be released.
1206  * ifname is only used for nlog().
1207  */
1208 static void
nwamd_down_interface(const char * aobjname,ipadm_addr_type_t atype,const char * ifname)1209 nwamd_down_interface(const char *aobjname, ipadm_addr_type_t atype,
1210     const char *ifname)
1211 {
1212 	ipadm_status_t ipstatus;
1213 	uint32_t rflags = (atype == IPADM_ADDR_DHCP ? IPADM_OPT_RELEASE : 0);
1214 
1215 	nlog(LOG_DEBUG, "nwamd_down_interface: %s [aobjname = %s]",
1216 	    ifname, aobjname);
1217 	if ((ipstatus = ipadm_delete_addr(ipadm_handle, aobjname,
1218 	    IPADM_OPT_ACTIVE | rflags)) != IPADM_SUCCESS) {
1219 		nlog(LOG_ERR, "nwamd_down_interface: "
1220 		    "ipadm_delete_addr failed on %s: %s",
1221 		    ifname, ipadm_status2str(ipstatus));
1222 	}
1223 }
1224 
1225 static void
unconfigure_addresses(nwamd_ncu_t * ncu,sa_family_t af)1226 unconfigure_addresses(nwamd_ncu_t *ncu, sa_family_t af)
1227 {
1228 	struct nwamd_if_address *nifap, *nifa = ncu->ncu_if.nwamd_if_list;
1229 
1230 	for (nifap = nifa; nifap != NULL; nifap = nifap->next)
1231 		if (af == AF_UNSPEC || nifap->family == af)
1232 			nifap->configured = B_FALSE;
1233 }
1234 
1235 static void
dhcp_release(const char * ifname)1236 dhcp_release(const char *ifname)
1237 {
1238 	ipadm_addr_info_t *ainfo, *ainfop;
1239 
1240 	if (ipadm_addr_info(ipadm_handle, ifname, &ainfo, 0, 0)
1241 	    != IPADM_SUCCESS)
1242 		return;
1243 
1244 	for (ainfop = ainfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
1245 		if (ainfop->ia_atype == IPADM_ADDR_DHCP)
1246 			nwamd_down_interface(ainfop->ia_aobjname,
1247 			    ainfop->ia_atype, ifname);
1248 	}
1249 	ipadm_free_addr_info(ainfo);
1250 }
1251 
1252 static void
nwamd_plumb_unplumb_interface(nwamd_ncu_t * ncu,sa_family_t af,boolean_t plumb)1253 nwamd_plumb_unplumb_interface(nwamd_ncu_t *ncu, sa_family_t af, boolean_t plumb)
1254 {
1255 	char *ifname = ncu->ncu_name;
1256 	nwamd_if_t *u_if = &ncu->ncu_if;
1257 	ipadm_status_t ipstatus;
1258 
1259 	nlog(LOG_DEBUG, "nwamd_plumb_unplumb_interface: %s %s %s",
1260 	    (plumb ? "plumb" : "unplumb"), (af == AF_INET ? "IPv4" : "IPv6"),
1261 	    ifname);
1262 
1263 	if (plumb) {
1264 		ipstatus = ipadm_create_if(ipadm_handle, ifname, af,
1265 		    IPADM_OPT_ACTIVE);
1266 	} else {
1267 		/* release DHCP address, if any */
1268 		if (af == AF_INET)
1269 			dhcp_release(ifname);
1270 		ipstatus = ipadm_delete_if(ipadm_handle, ifname, af,
1271 		    IPADM_OPT_ACTIVE);
1272 	}
1273 
1274 	if (ipstatus != IPADM_SUCCESS) {
1275 		if ((plumb && ipstatus != IPADM_IF_EXISTS) ||
1276 		    (!plumb && ipstatus != IPADM_ENXIO)) {
1277 			nlog(LOG_ERR, "nwamd_plumb_unplumb_interface: "
1278 			    "%s %s failed for %s: %s",
1279 			    (plumb ? "plumb" : "unplumb"),
1280 			    (af == AF_INET ? "IPv4" : "IPv6"),
1281 			    ifname, ipadm_status2str(ipstatus));
1282 		}
1283 	}
1284 
1285 	/* Unset flags */
1286 	if (!plumb) {
1287 		unconfigure_addresses(ncu, af);
1288 		switch (af) {
1289 		case AF_INET:
1290 			u_if->nwamd_if_dhcp_configured = B_FALSE;
1291 			break;
1292 		case AF_INET6:
1293 			u_if->nwamd_if_stateful_configured = B_FALSE;
1294 			u_if->nwamd_if_stateless_configured = B_FALSE;
1295 			break;
1296 		}
1297 	}
1298 }
1299 
1300 void
nwamd_plumb_interface(nwamd_ncu_t * ncu,sa_family_t af)1301 nwamd_plumb_interface(nwamd_ncu_t *ncu, sa_family_t af)
1302 {
1303 	/*
1304 	 * We get all posssible privs by calling nwamd_deescalate().  During
1305 	 * startup opening /dev/dld (data link management) needs all privs
1306 	 * because we don't have access to /etc/security/device_policy yet.
1307 	 */
1308 	nwamd_escalate();
1309 	nwamd_plumb_unplumb_interface(ncu, af, B_TRUE);
1310 	nwamd_deescalate();
1311 }
1312 
1313 void
nwamd_unplumb_interface(nwamd_ncu_t * ncu,sa_family_t af)1314 nwamd_unplumb_interface(nwamd_ncu_t *ncu, sa_family_t af)
1315 {
1316 	nwamd_plumb_unplumb_interface(ncu, af, B_FALSE);
1317 }
1318 
1319 static void *
start_dhcp_thread(void * arg)1320 start_dhcp_thread(void *arg)
1321 {
1322 	struct nwamd_dhcp_thread_arg *thread_arg = arg;
1323 	nwamd_object_t ncu_obj;
1324 	dhcp_ipc_type_t type;
1325 	char *name;
1326 	ipadm_addrobj_t ipaddr;
1327 	ipadm_status_t ipstatus;
1328 	int retries = 0;
1329 
1330 	name = thread_arg->name;
1331 	type = thread_arg->type;
1332 	ipaddr = thread_arg->ipaddr;
1333 
1334 retry:
1335 	/* Make sure the NCU is in appropriate state for DHCP command */
1336 	ncu_obj = nwamd_ncu_object_find(NWAM_NCU_TYPE_INTERFACE, name);
1337 	if (ncu_obj == NULL) {
1338 		nlog(LOG_ERR, "start_dhcp: no IP object %s", name);
1339 		return (NULL);
1340 	}
1341 
1342 	if (ncu_obj->nwamd_object_state != NWAM_STATE_OFFLINE_TO_ONLINE &&
1343 	    ncu_obj->nwamd_object_state != NWAM_STATE_ONLINE) {
1344 		nlog(LOG_INFO, "start_dhcp: IP NCU %s is in invalid state "
1345 		    "for DHCP command", ncu_obj->nwamd_object_name);
1346 		nwamd_object_release(ncu_obj);
1347 		return (NULL);
1348 	}
1349 	nwamd_object_release(ncu_obj);
1350 
1351 	switch (type) {
1352 	case DHCP_INFORM:
1353 	{
1354 		char aobjname[IPADM_AOBJSIZ];
1355 
1356 		if ((ipstatus = ipadm_get_aobjname(ipaddr, aobjname,
1357 		    sizeof (aobjname))) != IPADM_SUCCESS) {
1358 			nlog(LOG_ERR, "start_dhcp: "
1359 			    "ipadm_get_aobjname failed for %s: %s",
1360 			    name, ipadm_status2str(ipstatus));
1361 			goto done;
1362 		}
1363 		ipstatus = ipadm_refresh_addr(ipadm_handle, aobjname,
1364 		    IPADM_OPT_ACTIVE | IPADM_OPT_INFORM);
1365 		break;
1366 	}
1367 	case DHCP_START:
1368 		ipstatus = ipadm_create_addr(ipadm_handle, ipaddr,
1369 		    IPADM_OPT_ACTIVE);
1370 		break;
1371 	default:
1372 		nlog(LOG_ERR, "start_dhcp: invalid dhcp_ipc_type_t: %d", type);
1373 		goto done;
1374 	}
1375 
1376 	if (ipstatus == IPADM_DHCP_IPC_TIMEOUT) {
1377 		/*
1378 		 * DHCP timed out: for DHCP_START requests, change state for
1379 		 * this NCU and euqueue event to check NCU priority-groups;
1380 		 * for DHCP_INFORM requests, nothing to do.
1381 		 */
1382 		if (type == DHCP_START) {
1383 			char *object_name;
1384 
1385 			nlog(LOG_INFO,
1386 			    "start_dhcp: DHCP_START timed out for %s", name);
1387 
1388 			if (nwam_ncu_name_to_typed_name(name,
1389 			    NWAM_NCU_TYPE_INTERFACE, &object_name)
1390 			    != NWAM_SUCCESS) {
1391 				nlog(LOG_ERR, "start_dhcp: "
1392 				    "nwam_ncu_name_to_typed_name failed for %s",
1393 				    name);
1394 				goto done;
1395 			}
1396 			nwamd_object_set_state(NWAM_OBJECT_TYPE_NCU,
1397 			    object_name, NWAM_STATE_OFFLINE_TO_ONLINE,
1398 			    NWAM_AUX_STATE_IF_DHCP_TIMED_OUT);
1399 			nwamd_create_ncu_check_event(0);
1400 			free(object_name);
1401 		} else {
1402 			nlog(LOG_INFO,
1403 			    "start_dhcp: DHCP_INFORM timed out for %s", name);
1404 		}
1405 
1406 	} else if ((ipstatus == IPADM_DHCP_IPC_ERROR ||
1407 	    ipstatus == IPADM_IPC_ERROR) && retries++ < NWAMD_DHCP_RETRIES) {
1408 		/*
1409 		 * Retry DHCP request as we may have been unplumbing as part
1410 		 * of the configuration phase.
1411 		 */
1412 		nlog(LOG_ERR, "start_dhcp: ipadm_%s_addr on %s returned: %s, "
1413 		    "retrying in %d sec",
1414 		    (type == DHCP_START ? "create" : "refresh"), name,
1415 		    ipadm_status2str(ipstatus), NWAMD_DHCP_RETRY_WAIT_TIME);
1416 		(void) sleep(NWAMD_DHCP_RETRY_WAIT_TIME);
1417 		goto retry;
1418 
1419 	} else if (ipstatus != IPADM_SUCCESS) {
1420 		nlog(LOG_ERR, "start_dhcp: ipadm_%s_addr failed for %s: %s",
1421 		    (type == DHCP_START ? "create" : "refresh"), name,
1422 		    ipadm_status2str(ipstatus));
1423 	}
1424 
1425 done:
1426 	free(name);
1427 	free(arg);
1428 	return (NULL);
1429 }
1430 
1431 static void
nwamd_dhcp(const char * ifname,ipadm_addrobj_t ipaddr,dhcp_ipc_type_t cmd)1432 nwamd_dhcp(const char *ifname, ipadm_addrobj_t ipaddr, dhcp_ipc_type_t cmd)
1433 {
1434 	struct nwamd_dhcp_thread_arg *arg;
1435 	pthread_attr_t attr;
1436 
1437 	nlog(LOG_DEBUG, "nwamd_dhcp: starting DHCP %s thread for %s",
1438 	    dhcp_ipc_type_to_string(cmd), ifname);
1439 
1440 	arg = malloc(sizeof (*arg));
1441 	if (arg == NULL) {
1442 		nlog(LOG_ERR, "nwamd_dhcp: error allocating memory for "
1443 		    "dhcp request");
1444 		return;
1445 	}
1446 
1447 	arg->name = strdup(ifname);
1448 	arg->type = cmd;
1449 	arg->ipaddr = ipaddr;
1450 
1451 	(void) pthread_attr_init(&attr);
1452 	(void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1453 	if (pthread_create(NULL, &attr, start_dhcp_thread, arg) == -1) {
1454 		nlog(LOG_ERR, "nwamd_dhcp: cannot start dhcp thread");
1455 		free(arg->name);
1456 		free(arg);
1457 		(void) pthread_attr_destroy(&attr);
1458 		return;
1459 	}
1460 	(void) pthread_attr_destroy(&attr);
1461 }
1462