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 * Copyright 2015 Joyent, Inc.
25 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <stropts.h>
35 #include <sys/sockio.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <sys/socket.h>
39 #include <net/route.h>
40 #include <netinet/in.h>
41 #include <inet/ip.h>
42 #include <arpa/inet.h>
43 #include <libintl.h>
44 #include <libdlpi.h>
45 #include <libinetutil.h>
46 #include <libdladm.h>
47 #include <libdllink.h>
48 #include <libdliptun.h>
49 #include <strings.h>
50 #include <zone.h>
51 #include <ctype.h>
52 #include <limits.h>
53 #include <assert.h>
54 #include <netdb.h>
55 #include <pwd.h>
56 #include <auth_attr.h>
57 #include <secdb.h>
58 #include <nss_dbdefs.h>
59 #include "libipadm_impl.h"
60
61 /* error codes and text description */
62 static struct ipadm_error_info {
63 ipadm_status_t error_code;
64 const char *error_desc;
65 } ipadm_errors[] = {
66 { IPADM_SUCCESS, "Operation succeeded" },
67 { IPADM_FAILURE, "Operation failed" },
68 { IPADM_EAUTH, "Insufficient user authorizations" },
69 { IPADM_EPERM, "Permission denied" },
70 { IPADM_NO_BUFS, "No buffer space available" },
71 { IPADM_NO_MEMORY, "Insufficient memory" },
72 { IPADM_BAD_ADDR, "Invalid address" },
73 { IPADM_BAD_PROTOCOL, "Incorrect protocol family for operation" },
74 { IPADM_DAD_FOUND, "Duplicate address detected" },
75 { IPADM_EXISTS, "Already exists" },
76 { IPADM_IF_EXISTS, "Interface already exists" },
77 { IPADM_ADDROBJ_EXISTS, "Address object already exists" },
78 { IPADM_ADDRCONF_EXISTS, "Addrconf already in progress" },
79 { IPADM_ENXIO, "Interface does not exist" },
80 { IPADM_GRP_NOTEMPTY, "IPMP group is not empty" },
81 { IPADM_INVALID_ARG, "Invalid argument provided" },
82 { IPADM_INVALID_NAME, "Invalid name" },
83 { IPADM_DLPI_FAILURE, "Could not open DLPI link" },
84 { IPADM_DLADM_FAILURE, "Datalink does not exist" },
85 { IPADM_PROP_UNKNOWN, "Unknown property" },
86 { IPADM_ERANGE, "Value is outside the allowed range" },
87 { IPADM_ESRCH, "Value does not exist" },
88 { IPADM_EOVERFLOW, "Number of values exceeds the allowed limit" },
89 { IPADM_NOTFOUND, "Object not found" },
90 { IPADM_IF_INUSE, "Interface already in use" },
91 { IPADM_ADDR_INUSE, "Address already in use" },
92 { IPADM_BAD_HOSTNAME, "Hostname maps to multiple IP addresses" },
93 { IPADM_ADDR_NOTAVAIL, "Can't assign requested address" },
94 { IPADM_ALL_ADDRS_NOT_ENABLED, "All addresses could not be enabled" },
95 { IPADM_NDPD_NOT_RUNNING, "IPv6 autoconf daemon in.ndpd not running" },
96 { IPADM_DHCP_START_ERROR, "Could not start dhcpagent" },
97 { IPADM_DHCP_IPC_ERROR, "Could not communicate with dhcpagent" },
98 { IPADM_DHCP_IPC_TIMEOUT, "Communication with dhcpagent timed out" },
99 { IPADM_TEMPORARY_OBJ, "Persistent operation on temporary object" },
100 { IPADM_IPC_ERROR, "Could not communicate with ipmgmtd" },
101 { IPADM_NOTSUP, "Operation not supported" },
102 { IPADM_OP_DISABLE_OBJ, "Operation not supported on disabled object" },
103 { IPADM_EBADE, "Invalid data exchange with daemon" },
104 { IPADM_GZ_PERM, "Operation not permitted on from-gz interface"}
105 };
106
107 #define IPADM_NUM_ERRORS (sizeof (ipadm_errors) / sizeof (*ipadm_errors))
108
109 ipadm_status_t
110 ipadm_errno2status(int error)
111 {
112 switch (error) {
113 case 0:
114 return (IPADM_SUCCESS);
115 case ENXIO:
116 return (IPADM_ENXIO);
117 case ENOMEM:
118 return (IPADM_NO_MEMORY);
119 case ENOBUFS:
120 return (IPADM_NO_BUFS);
121 case EINVAL:
122 return (IPADM_INVALID_ARG);
123 case EBUSY:
124 return (IPADM_IF_INUSE);
125 case EEXIST:
126 return (IPADM_EXISTS);
127 case EADDRNOTAVAIL:
128 return (IPADM_ADDR_NOTAVAIL);
129 case EADDRINUSE:
130 return (IPADM_ADDR_INUSE);
131 case ENOENT:
132 return (IPADM_NOTFOUND);
133 case ERANGE:
134 return (IPADM_ERANGE);
135 case EPERM:
136 return (IPADM_EPERM);
137 case ENOTSUP:
138 case EOPNOTSUPP:
139 return (IPADM_NOTSUP);
140 case EBADF:
141 return (IPADM_IPC_ERROR);
142 case EBADE:
143 return (IPADM_EBADE);
144 case ESRCH:
145 return (IPADM_ESRCH);
146 case EOVERFLOW:
147 return (IPADM_EOVERFLOW);
148 default:
149 return (IPADM_FAILURE);
150 }
151 }
152
153 /*
154 * Returns a message string for the given libipadm error status.
155 */
156 const char *
157 ipadm_status2str(ipadm_status_t status)
158 {
159 int i;
160
161 for (i = 0; i < IPADM_NUM_ERRORS; i++) {
162 if (status == ipadm_errors[i].error_code)
163 return (dgettext(TEXT_DOMAIN,
164 ipadm_errors[i].error_desc));
165 }
166
167 return (dgettext(TEXT_DOMAIN, "<unknown error>"));
168 }
169
170 /*
171 * Opens a handle to libipadm.
172 * Possible values for flags:
173 * IPH_VRRP: Used by VRRP daemon to set the socket option SO_VRRP.
174 * IPH_LEGACY: This is used whenever an application needs to provide a
175 * logical interface name while creating or deleting
176 * interfaces and static addresses.
177 * IPH_INIT: Used by ipadm_init_prop(), to initialize protocol properties
178 * on reboot.
179 */
180 ipadm_status_t
181 ipadm_open(ipadm_handle_t *handle, uint32_t flags)
182 {
183 ipadm_handle_t iph;
184 ipadm_status_t status = IPADM_SUCCESS;
185 zoneid_t zoneid;
186 ushort_t zflags;
187 int on = B_TRUE;
188
189 if (handle == NULL)
190 return (IPADM_INVALID_ARG);
191 *handle = NULL;
192
193 if (flags & ~(IPH_VRRP|IPH_LEGACY|IPH_INIT|IPH_IPMGMTD))
194 return (IPADM_INVALID_ARG);
195
196 if ((iph = calloc(1, sizeof (struct ipadm_handle))) == NULL)
197 return (IPADM_NO_MEMORY);
198 iph->iph_sock = -1;
199 iph->iph_sock6 = -1;
200 iph->iph_door_fd = -1;
201 iph->iph_rtsock = -1;
202 iph->iph_flags = flags;
203 (void) pthread_mutex_init(&iph->iph_lock, NULL);
204
205 if ((iph->iph_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ||
206 (iph->iph_sock6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
207 goto errnofail;
208 }
209
210 /*
211 * We open a handle to libdladm here, to facilitate some daemons (like
212 * nwamd) which opens handle to libipadm before devfsadmd installs the
213 * right device permissions into the kernel and requires "all"
214 * privileges to open DLD_CONTROL_DEV.
215 *
216 * In a non-global shared-ip zone there will be no DLD_CONTROL_DEV node
217 * and dladm_open() will fail. So, we avoid this by not calling
218 * dladm_open() for such zones.
219 */
220 zoneid = getzoneid();
221 iph->iph_zoneid = zoneid;
222 if (zoneid != GLOBAL_ZONEID) {
223 if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &zflags,
224 sizeof (zflags)) < 0) {
225 goto errnofail;
226 }
227 }
228 if ((zoneid == GLOBAL_ZONEID) || (zflags & ZF_NET_EXCL)) {
229 if (dladm_open(&iph->iph_dlh) != DLADM_STATUS_OK) {
230 ipadm_close(iph);
231 return (IPADM_DLADM_FAILURE);
232 }
233 if (zoneid != GLOBAL_ZONEID) {
234 iph->iph_rtsock = socket(PF_ROUTE, SOCK_RAW, 0);
235 /*
236 * Failure to open rtsock is ignored as this is
237 * only used in non-global zones to initialize
238 * routing socket information.
239 */
240 }
241 } else {
242 assert(zoneid != GLOBAL_ZONEID);
243 iph->iph_dlh = NULL;
244 }
245 if (flags & IPH_VRRP) {
246 if (setsockopt(iph->iph_sock6, SOL_SOCKET, SO_VRRP, &on,
247 sizeof (on)) < 0 || setsockopt(iph->iph_sock, SOL_SOCKET,
248 SO_VRRP, &on, sizeof (on)) < 0) {
249 goto errnofail;
250 }
251 }
252 *handle = iph;
253 return (status);
254
255 errnofail:
256 status = ipadm_errno2status(errno);
257 ipadm_close(iph);
258 return (status);
259 }
260
261 /*
262 * Closes and frees the libipadm handle.
263 */
264 void
265 ipadm_close(ipadm_handle_t iph)
266 {
267 if (iph == NULL)
268 return;
269 if (iph->iph_sock != -1)
270 (void) close(iph->iph_sock);
271 if (iph->iph_sock6 != -1)
272 (void) close(iph->iph_sock6);
273 if (iph->iph_rtsock != -1)
274 (void) close(iph->iph_rtsock);
275 if (iph->iph_door_fd != -1)
276 (void) close(iph->iph_door_fd);
277 dladm_close(iph->iph_dlh);
278 (void) pthread_mutex_destroy(&iph->iph_lock);
279 free(iph);
280 }
281
282 /*
283 * Checks if the caller has the authorization to configure network
284 * interfaces.
285 */
286 boolean_t
287 ipadm_check_auth(void)
288 {
289 int uid;
290 struct passwd pwd;
291 char buf[NSS_BUFLEN_PASSWD];
292
293 /*
294 * Branded zones may have different kinds of auth, but root always
295 * allowed.
296 */
297 if ((uid = getuid()) == 0)
298 return (B_TRUE);
299
300 /* get the password entry for the given user ID */
301 if (getpwuid_r(uid, &pwd, buf, sizeof (buf)) == NULL)
302 return (B_FALSE);
303
304 /* check for presence of given authorization */
305 return (chkauthattr(NETWORK_INTERFACE_CONFIG_AUTH, pwd.pw_name) != 0);
306 }
307
308 /*
309 * Stores the index value of the interface in `ifname' for the address
310 * family `af' into the buffer pointed to by `index'.
311 */
312 static ipadm_status_t
313 i_ipadm_get_index(ipadm_handle_t iph, const char *ifname, sa_family_t af,
314 int *index)
315 {
316 struct lifreq lifr;
317 int sock;
318
319 bzero(&lifr, sizeof (lifr));
320 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
321 if (af == AF_INET)
322 sock = iph->iph_sock;
323 else
324 sock = iph->iph_sock6;
325
326 if (ioctl(sock, SIOCGLIFINDEX, (caddr_t)&lifr) < 0)
327 return (ipadm_errno2status(errno));
328 *index = lifr.lifr_index;
329
330 return (IPADM_SUCCESS);
331 }
332
333 /*
334 * Maximum amount of time (in milliseconds) to wait for Duplicate Address
335 * Detection to complete in the kernel.
336 */
337 #define DAD_WAIT_TIME 1000
338
339 /*
340 * Any time that flags are changed on an interface where either the new or the
341 * existing flags have IFF_UP set, we'll get a RTM_NEWADDR message to
342 * announce the new address added and its flag status.
343 * We wait here for that message and look for IFF_UP.
344 * If something's amiss with the kernel, though, we don't wait forever.
345 * (Note that IFF_DUPLICATE is a high-order bit, and we cannot see
346 * it in the routing socket messages.)
347 */
348 static ipadm_status_t
349 i_ipadm_dad_wait(ipadm_handle_t handle, const char *lifname, sa_family_t af,
350 int rtsock)
351 {
352 struct pollfd fds[1];
353 union {
354 struct if_msghdr ifm;
355 char buf[1024];
356 } msg;
357 int index;
358 ipadm_status_t retv;
359 uint64_t flags;
360 hrtime_t starttime, now;
361
362 fds[0].fd = rtsock;
363 fds[0].events = POLLIN;
364 fds[0].revents = 0;
365
366 retv = i_ipadm_get_index(handle, lifname, af, &index);
367 if (retv != IPADM_SUCCESS)
368 return (retv);
369
370 starttime = gethrtime();
371 for (;;) {
372 now = gethrtime();
373 now = (now - starttime) / 1000000;
374 if (now >= DAD_WAIT_TIME)
375 break;
376 if (poll(fds, 1, DAD_WAIT_TIME - (int)now) <= 0)
377 break;
378 if (read(rtsock, &msg, sizeof (msg)) <= 0)
379 break;
380 if (msg.ifm.ifm_type != RTM_NEWADDR)
381 continue;
382 /* Note that ifm_index is just 16 bits */
383 if (index == msg.ifm.ifm_index && (msg.ifm.ifm_flags & IFF_UP))
384 return (IPADM_SUCCESS);
385 }
386
387 retv = i_ipadm_get_flags(handle, lifname, af, &flags);
388 if (retv != IPADM_SUCCESS)
389 return (retv);
390 if (flags & IFF_DUPLICATE)
391 return (IPADM_DAD_FOUND);
392
393 return (IPADM_SUCCESS);
394 }
395
396 /*
397 * Sets the flags `on_flags' and resets the flags `off_flags' for the logical
398 * interface in `lifname'.
399 *
400 * If the new flags value will transition the interface from "down" to "up"
401 * then duplicate address detection is performed by the kernel. This routine
402 * waits to get the outcome of that test.
403 */
404 ipadm_status_t
405 i_ipadm_set_flags(ipadm_handle_t iph, const char *lifname, sa_family_t af,
406 uint64_t on_flags, uint64_t off_flags)
407 {
408 struct lifreq lifr;
409 uint64_t oflags;
410 ipadm_status_t ret;
411 int rtsock = -1;
412 int sock, err;
413
414 ret = i_ipadm_get_flags(iph, lifname, af, &oflags);
415 if (ret != IPADM_SUCCESS)
416 return (ret);
417
418 sock = (af == AF_INET ? iph->iph_sock : iph->iph_sock6);
419
420 /*
421 * Any time flags are changed on an interface that has IFF_UP set,
422 * we get a routing socket message. We care about the status,
423 * though, only when the new flags are marked "up."
424 */
425 if (!(oflags & IFF_UP) && (on_flags & IFF_UP))
426 rtsock = socket(PF_ROUTE, SOCK_RAW, af);
427
428 oflags |= on_flags;
429 oflags &= ~off_flags;
430 bzero(&lifr, sizeof (lifr));
431 (void) strlcpy(lifr.lifr_name, lifname, sizeof (lifr.lifr_name));
432 lifr.lifr_flags = oflags;
433 if (ioctl(sock, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) {
434 err = errno;
435 if (rtsock != -1)
436 (void) close(rtsock);
437 return (ipadm_errno2status(err));
438 }
439 if (rtsock == -1) {
440 return (IPADM_SUCCESS);
441 } else {
442 /* Wait for DAD to complete. */
443 ret = i_ipadm_dad_wait(iph, lifname, af, rtsock);
444 (void) close(rtsock);
445 return (ret);
446 }
447 }
448
449 /*
450 * Returns the flags value for the logical interface in `lifname'
451 * in the buffer pointed to by `flags'.
452 */
453 ipadm_status_t
454 i_ipadm_get_flags(ipadm_handle_t iph, const char *lifname, sa_family_t af,
455 uint64_t *flags)
456 {
457 struct lifreq lifr;
458 int sock;
459
460 bzero(&lifr, sizeof (lifr));
461 (void) strlcpy(lifr.lifr_name, lifname, sizeof (lifr.lifr_name));
462 if (af == AF_INET)
463 sock = iph->iph_sock;
464 else
465 sock = iph->iph_sock6;
466
467 if (ioctl(sock, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
468 return (ipadm_errno2status(errno));
469 }
470 *flags = lifr.lifr_flags;
471
472 return (IPADM_SUCCESS);
473 }
474
475 /*
476 * Determines whether or not an interface name represents a loopback
477 * interface, before the interface has been plumbed.
478 * It is assumed that the interface name in `ifname' is of correct format
479 * as verified by ifparse_ifspec().
480 *
481 * Returns: B_TRUE if loopback, B_FALSE if not.
482 */
483 boolean_t
484 i_ipadm_is_loopback(const char *ifname)
485 {
486 int len = strlen(LOOPBACK_IF);
487
488 return (strncmp(ifname, LOOPBACK_IF, len) == 0 &&
489 (ifname[len] == '\0' || ifname[len] == IPADM_LOGICAL_SEP));
490 }
491
492 /*
493 * Determines whether or not an interface name represents a vni
494 * interface, before the interface has been plumbed.
495 * It is assumed that the interface name in `ifname' is of correct format
496 * as verified by ifparse_ifspec().
497 *
498 * Returns: B_TRUE if vni, B_FALSE if not.
499 */
500 boolean_t
501 i_ipadm_is_vni(const char *ifname)
502 {
503 ifspec_t ifsp;
504
505 return (ifparse_ifspec(ifname, &ifsp) &&
506 strcmp(ifsp.ifsp_devnm, "vni") == 0);
507 }
508
509 /*
510 * Returns B_TRUE if `ifname' is an IP interface on a 6to4 tunnel.
511 */
512 boolean_t
513 i_ipadm_is_6to4(ipadm_handle_t iph, char *ifname)
514 {
515 dladm_status_t dlstatus;
516 datalink_class_t class;
517 iptun_params_t params;
518 datalink_id_t linkid;
519
520 if (iph->iph_dlh == NULL) {
521 assert(iph->iph_zoneid != GLOBAL_ZONEID);
522 return (B_FALSE);
523 }
524 dlstatus = dladm_name2info(iph->iph_dlh, ifname, &linkid, NULL,
525 &class, NULL);
526 if (dlstatus == DLADM_STATUS_OK && class == DATALINK_CLASS_IPTUN) {
527 params.iptun_param_linkid = linkid;
528 dlstatus = dladm_iptun_getparams(iph->iph_dlh, ¶ms,
529 DLADM_OPT_ACTIVE);
530 if (dlstatus == DLADM_STATUS_OK &&
531 params.iptun_param_type == IPTUN_TYPE_6TO4) {
532 return (B_TRUE);
533 }
534 }
535 return (B_FALSE);
536 }
537
538 /*
539 * Returns B_TRUE if `ifname' represents an IPMP underlying interface.
540 */
541 boolean_t
542 i_ipadm_is_under_ipmp(ipadm_handle_t iph, const char *ifname)
543 {
544 struct lifreq lifr;
545
546 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
547 if (ioctl(iph->iph_sock, SIOCGLIFGROUPNAME, (caddr_t)&lifr) < 0) {
548 if (ioctl(iph->iph_sock6, SIOCGLIFGROUPNAME,
549 (caddr_t)&lifr) < 0) {
550 return (B_FALSE);
551 }
552 }
553 return (lifr.lifr_groupname[0] != '\0');
554 }
555
556 /*
557 * Returns B_TRUE if `ifname' represents an IPMP meta-interface.
558 */
559 boolean_t
560 i_ipadm_is_ipmp(ipadm_handle_t iph, const char *ifname)
561 {
562 uint64_t flags;
563
564 if (i_ipadm_get_flags(iph, ifname, AF_INET, &flags) != IPADM_SUCCESS &&
565 i_ipadm_get_flags(iph, ifname, AF_INET6, &flags) != IPADM_SUCCESS)
566 return (B_FALSE);
567
568 return ((flags & IFF_IPMP) != 0);
569 }
570
571 /*
572 * For a given interface name, ipadm_if_enabled() checks if v4
573 * or v6 or both IP interfaces exist in the active configuration.
574 */
575 boolean_t
576 ipadm_if_enabled(ipadm_handle_t iph, const char *ifname, sa_family_t af)
577 {
578 struct lifreq lifr;
579 int s4 = iph->iph_sock;
580 int s6 = iph->iph_sock6;
581
582 bzero(&lifr, sizeof (lifr));
583 (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
584 switch (af) {
585 case AF_INET:
586 if (ioctl(s4, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0)
587 return (B_TRUE);
588 break;
589 case AF_INET6:
590 if (ioctl(s6, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0)
591 return (B_TRUE);
592 break;
593 case AF_UNSPEC:
594 if (ioctl(s4, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0 ||
595 ioctl(s6, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0) {
596 return (B_TRUE);
597 }
598 }
599 return (B_FALSE);
600 }
601
602 /*
603 * Apply the interface property by retrieving information from nvl.
604 */
605 static ipadm_status_t
606 i_ipadm_init_ifprop(ipadm_handle_t iph, nvlist_t *nvl)
607 {
608 nvpair_t *nvp;
609 char *name, *pname = NULL;
610 char *protostr = NULL, *ifname = NULL, *pval = NULL;
611 uint_t proto;
612 int err = 0;
613
614 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
615 nvp = nvlist_next_nvpair(nvl, nvp)) {
616 name = nvpair_name(nvp);
617 if (strcmp(name, IPADM_NVP_IFNAME) == 0) {
618 if ((err = nvpair_value_string(nvp, &ifname)) != 0)
619 break;
620 } else if (strcmp(name, IPADM_NVP_PROTONAME) == 0) {
621 if ((err = nvpair_value_string(nvp, &protostr)) != 0)
622 break;
623 } else {
624 assert(!IPADM_PRIV_NVP(name));
625 pname = name;
626 if ((err = nvpair_value_string(nvp, &pval)) != 0)
627 break;
628 }
629 }
630 if (err != 0)
631 return (ipadm_errno2status(err));
632 proto = ipadm_str2proto(protostr);
633 return (ipadm_set_ifprop(iph, ifname, pname, pval, proto,
634 IPADM_OPT_ACTIVE));
635 }
636
637 /*
638 * Instantiate the address object or set the address object property by
639 * retrieving the configuration from the nvlist `nvl'.
640 */
641 ipadm_status_t
642 i_ipadm_init_addrobj(ipadm_handle_t iph, nvlist_t *nvl)
643 {
644 nvpair_t *nvp;
645 char *name;
646 char *aobjname = NULL, *pval = NULL, *ifname = NULL;
647 sa_family_t af = AF_UNSPEC;
648 ipadm_addr_type_t atype = IPADM_ADDR_NONE;
649 int err = 0;
650 ipadm_status_t status = IPADM_SUCCESS;
651
652 for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
653 nvp = nvlist_next_nvpair(nvl, nvp)) {
654 name = nvpair_name(nvp);
655 if (strcmp(name, IPADM_NVP_IFNAME) == 0) {
656 if ((err = nvpair_value_string(nvp, &ifname)) != 0)
657 break;
658 } else if (strcmp(name, IPADM_NVP_AOBJNAME) == 0) {
659 if ((err = nvpair_value_string(nvp, &aobjname)) != 0)
660 break;
661 } else if (i_ipadm_name2atype(name, &af, &atype)) {
662 break;
663 } else {
664 assert(!IPADM_PRIV_NVP(name));
665 err = nvpair_value_string(nvp, &pval);
666 break;
667 }
668 }
669 if (err != 0)
670 return (ipadm_errno2status(err));
671
672 switch (atype) {
673 case IPADM_ADDR_STATIC:
674 status = i_ipadm_enable_static(iph, ifname, nvl, af);
675 break;
676 case IPADM_ADDR_DHCP:
677 status = i_ipadm_enable_dhcp(iph, ifname, nvl);
678 if (status == IPADM_DHCP_IPC_TIMEOUT)
679 status = IPADM_SUCCESS;
680 break;
681 case IPADM_ADDR_IPV6_ADDRCONF:
682 status = i_ipadm_enable_addrconf(iph, ifname, nvl);
683 break;
684 case IPADM_ADDR_NONE:
685 status = ipadm_set_addrprop(iph, name, pval, aobjname,
686 IPADM_OPT_ACTIVE);
687 break;
688 }
689
690 return (status);
691 }
692
693 /*
694 * Instantiate the interface object by retrieving the configuration from
695 * `ifnvl'. The nvlist `ifnvl' contains all the persistent configuration
696 * (interface properties and address objects on that interface) for the
697 * given `ifname'.
698 */
699 ipadm_status_t
700 i_ipadm_init_ifobj(ipadm_handle_t iph, const char *ifname, nvlist_t *ifnvl)
701 {
702 nvlist_t *nvl = NULL;
703 nvpair_t *nvp;
704 char *afstr;
705 ipadm_status_t status;
706 ipadm_status_t ret_status = IPADM_SUCCESS;
707 char newifname[LIFNAMSIZ];
708 char *aobjstr;
709 sa_family_t af = AF_UNSPEC;
710 boolean_t is_ngz = (iph->iph_zoneid != GLOBAL_ZONEID);
711
712 (void) strlcpy(newifname, ifname, sizeof (newifname));
713 /*
714 * First plumb the given interface and then apply all the persistent
715 * interface properties and then instantiate any persistent addresses
716 * objects on that interface.
717 */
718 for (nvp = nvlist_next_nvpair(ifnvl, NULL); nvp != NULL;
719 nvp = nvlist_next_nvpair(ifnvl, nvp)) {
720 if (nvpair_value_nvlist(nvp, &nvl) != 0)
721 continue;
722
723 if (nvlist_lookup_string(nvl, IPADM_NVP_FAMILY, &afstr) == 0) {
724 status = i_ipadm_plumb_if(iph, newifname, atoi(afstr),
725 IPADM_OPT_ACTIVE);
726 /*
727 * If the interface is already plumbed, we should
728 * ignore this error because there might be address
729 * address objects on that interface that needs to
730 * be enabled again.
731 */
732 if (status == IPADM_IF_EXISTS)
733 status = IPADM_SUCCESS;
734
735 if (is_ngz)
736 af = atoi(afstr);
737 } else if (nvlist_lookup_string(nvl, IPADM_NVP_AOBJNAME,
738 &aobjstr) == 0) {
739 /*
740 * For a static address, we need to search for
741 * the prefixlen in the nvlist `ifnvl'.
742 */
743 if (nvlist_exists(nvl, IPADM_NVP_IPV4ADDR) ||
744 nvlist_exists(nvl, IPADM_NVP_IPV6ADDR)) {
745 status = i_ipadm_merge_prefixlen_from_nvl(ifnvl,
746 nvl, aobjstr);
747 if (status != IPADM_SUCCESS)
748 continue;
749 }
750 status = i_ipadm_init_addrobj(iph, nvl);
751 /*
752 * If this address is in use on some other interface,
753 * we want to record an error to be returned as
754 * a soft error and continue processing the rest of
755 * the addresses.
756 */
757 if (status == IPADM_ADDR_NOTAVAIL) {
758 ret_status = IPADM_ALL_ADDRS_NOT_ENABLED;
759 status = IPADM_SUCCESS;
760 }
761 } else {
762 assert(nvlist_exists(nvl, IPADM_NVP_PROTONAME));
763 status = i_ipadm_init_ifprop(iph, nvl);
764 }
765 if (status != IPADM_SUCCESS)
766 return (status);
767 }
768
769 if (is_ngz && af != AF_UNSPEC)
770 ret_status = ipadm_init_net_from_gz(iph, newifname, NULL);
771 return (ret_status);
772 }
773
774 /*
775 * Retrieves the persistent configuration for the given interface(s) in `ifs'
776 * by contacting the daemon and dumps the information in `allifs'.
777 */
778 ipadm_status_t
779 i_ipadm_init_ifs(ipadm_handle_t iph, const char *ifs, nvlist_t **allifs)
780 {
781 nvlist_t *nvl = NULL;
782 size_t nvlsize, bufsize;
783 ipmgmt_initif_arg_t *iargp;
784 char *buf = NULL, *nvlbuf = NULL;
785 ipmgmt_get_rval_t *rvalp = NULL;
786 int err;
787 ipadm_status_t status = IPADM_SUCCESS;
788
789 if ((err = ipadm_str2nvlist(ifs, &nvl, IPADM_NORVAL)) != 0)
790 return (ipadm_errno2status(err));
791
792 err = nvlist_pack(nvl, &nvlbuf, &nvlsize, NV_ENCODE_NATIVE, 0);
793 if (err != 0) {
794 status = ipadm_errno2status(err);
795 goto done;
796 }
797 bufsize = sizeof (*iargp) + nvlsize;
798 if ((buf = malloc(bufsize)) == NULL) {
799 status = ipadm_errno2status(errno);
800 goto done;
801 }
802
803 /* populate the door_call argument structure */
804 iargp = (void *)buf;
805 iargp->ia_cmd = IPMGMT_CMD_INITIF;
806 iargp->ia_flags = 0;
807 iargp->ia_family = AF_UNSPEC;
808 iargp->ia_nvlsize = nvlsize;
809 (void) bcopy(nvlbuf, buf + sizeof (*iargp), nvlsize);
810
811 if ((rvalp = malloc(sizeof (ipmgmt_get_rval_t))) == NULL) {
812 status = ipadm_errno2status(errno);
813 goto done;
814 }
815 if ((err = ipadm_door_call(iph, iargp, bufsize, (void **)&rvalp,
816 sizeof (*rvalp), B_TRUE)) != 0) {
817 status = ipadm_errno2status(err);
818 goto done;
819 }
820
821 /*
822 * Daemon reply pointed to by rvalp contains ipmgmt_get_rval_t structure
823 * followed by a list of packed nvlists, each of which represents
824 * configuration information for the given interface(s).
825 */
826 err = nvlist_unpack((char *)rvalp + sizeof (ipmgmt_get_rval_t),
827 rvalp->ir_nvlsize, allifs, NV_ENCODE_NATIVE);
828 if (err != 0)
829 status = ipadm_errno2status(err);
830 done:
831 nvlist_free(nvl);
832 free(buf);
833 free(nvlbuf);
834 free(rvalp);
835 return (status);
836 }
837
838 /*
839 * Returns B_FALSE if
840 * (1) `ifname' is NULL or has no string or has a string of invalid length
841 * (2) ifname is a logical interface and IPH_LEGACY is not set, or
842 */
843 boolean_t
844 i_ipadm_validate_ifname(ipadm_handle_t iph, const char *ifname)
845 {
846 ifspec_t ifsp;
847
848 if (ifname == NULL || ifname[0] == '\0' ||
849 !ifparse_ifspec(ifname, &ifsp))
850 return (B_FALSE);
851 if (ifsp.ifsp_lunvalid)
852 return (ifsp.ifsp_lun > 0 && (iph->iph_flags & IPH_LEGACY));
853 return (B_TRUE);
854 }
855
856 /*
857 * Wrapper for sending a non-transparent I_STR ioctl().
858 * Returns: Result from ioctl().
859 */
860 int
861 i_ipadm_strioctl(int s, int cmd, char *buf, int buflen)
862 {
863 struct strioctl ioc;
864
865 (void) memset(&ioc, 0, sizeof (ioc));
866 ioc.ic_cmd = cmd;
867 ioc.ic_timout = 0;
868 ioc.ic_len = buflen;
869 ioc.ic_dp = buf;
870
871 return (ioctl(s, I_STR, (char *)&ioc));
872 }
873
874 /*
875 * Make a door call to the server and checks if the door call succeeded or not.
876 * `is_varsize' specifies that the data returned by ipmgmtd daemon is of
877 * variable size and door will allocate buffer using mmap(). In such cases
878 * we re-allocate the required memory,n assign it to `rbufp', copy the data to
879 * `rbufp' and then call munmap() (see below).
880 *
881 * It also checks to see if the server side procedure ran successfully by
882 * checking for ir_err. Therefore, for some callers who just care about the
883 * return status can set `rbufp' to NULL and set `rsize' to 0.
884 */
885 int
886 ipadm_door_call(ipadm_handle_t iph, void *arg, size_t asize, void **rbufp,
887 size_t rsize, boolean_t is_varsize)
888 {
889 door_arg_t darg;
890 int err;
891 ipmgmt_retval_t rval, *rvalp;
892 boolean_t reopen = B_FALSE;
893
894 if (rbufp == NULL) {
895 rvalp = &rval;
896 rbufp = (void **)&rvalp;
897 rsize = sizeof (rval);
898 }
899
900 darg.data_ptr = arg;
901 darg.data_size = asize;
902 darg.desc_ptr = NULL;
903 darg.desc_num = 0;
904 darg.rbuf = *rbufp;
905 darg.rsize = rsize;
906
907 reopen:
908 (void) pthread_mutex_lock(&iph->iph_lock);
909 /*
910 * The door descriptor is opened if it isn't already.
911 */
912 if (iph->iph_door_fd == -1) {
913 char door[MAXPATHLEN];
914 const char *zroot = zone_get_nroot();
915
916 /*
917 * If this is a branded zone, make sure we use the "/native"
918 * prefix for the door path:
919 */
920 (void) snprintf(door, sizeof (door), "%s%s", zroot != NULL ?
921 zroot : "", IPMGMT_DOOR);
922
923 if ((iph->iph_door_fd = open(door, O_RDONLY)) < 0) {
924 err = errno;
925 (void) pthread_mutex_unlock(&iph->iph_lock);
926 return (err);
927 }
928 }
929 (void) pthread_mutex_unlock(&iph->iph_lock);
930
931 if (door_call(iph->iph_door_fd, &darg) == -1) {
932 /*
933 * Stale door descriptor is possible if ipmgmtd was restarted
934 * since last iph_door_fd was opened, so try re-opening door
935 * descriptor.
936 */
937 if (!reopen && errno == EBADF) {
938 (void) close(iph->iph_door_fd);
939 iph->iph_door_fd = -1;
940 reopen = B_TRUE;
941 goto reopen;
942 }
943 return (errno);
944 }
945 err = ((ipmgmt_retval_t *)(void *)(darg.rbuf))->ir_err;
946 if (darg.rbuf != *rbufp) {
947 /*
948 * if the caller is expecting the result to fit in specified
949 * buffer then return failure.
950 */
951 if (!is_varsize)
952 err = EBADE;
953 /*
954 * The size of the buffer `*rbufp' was not big enough
955 * and the door itself allocated buffer, for us. We will
956 * hit this, on several occasion as for some cases
957 * we cannot predict the size of the return structure.
958 * Reallocate the buffer `*rbufp' and memcpy() the contents
959 * to new buffer.
960 */
961 if (err == 0) {
962 void *newp;
963
964 /* allocated memory will be freed by the caller */
965 if ((newp = realloc(*rbufp, darg.rsize)) == NULL) {
966 err = ENOMEM;
967 } else {
968 *rbufp = newp;
969 (void) memcpy(*rbufp, darg.rbuf, darg.rsize);
970 }
971 }
972 /* munmap() the door buffer */
973 (void) munmap(darg.rbuf, darg.rsize);
974 } else {
975 if (darg.rsize != rsize)
976 err = EBADE;
977 }
978 return (err);
979 }