16e91bba0SGirish Moodalbail /*
26e91bba0SGirish Moodalbail * CDDL HEADER START
36e91bba0SGirish Moodalbail *
46e91bba0SGirish Moodalbail * The contents of this file are subject to the terms of the
56e91bba0SGirish Moodalbail * Common Development and Distribution License (the "License").
66e91bba0SGirish Moodalbail * You may not use this file except in compliance with the License.
76e91bba0SGirish Moodalbail *
86e91bba0SGirish Moodalbail * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
96e91bba0SGirish Moodalbail * or http://www.opensolaris.org/os/licensing.
106e91bba0SGirish Moodalbail * See the License for the specific language governing permissions
116e91bba0SGirish Moodalbail * and limitations under the License.
126e91bba0SGirish Moodalbail *
136e91bba0SGirish Moodalbail * When distributing Covered Code, include this CDDL HEADER in each
146e91bba0SGirish Moodalbail * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
156e91bba0SGirish Moodalbail * If applicable, add the following below this CDDL HEADER, with the
166e91bba0SGirish Moodalbail * fields enclosed by brackets "[]" replaced with your own identifying
176e91bba0SGirish Moodalbail * information: Portions Copyright [yyyy] [name of copyright owner]
186e91bba0SGirish Moodalbail *
196e91bba0SGirish Moodalbail * CDDL HEADER END
206e91bba0SGirish Moodalbail */
21ad69a334SYuri Pankov
226e91bba0SGirish Moodalbail /*
23f6da83d4SAnurag S. Maskey * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24b31320a7SChris Fraire * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
25a73be61aSHans Rosenfeld * Copyright 2021 Tintri by DDN, Inc. All rights reserved.
266e91bba0SGirish Moodalbail */
276e91bba0SGirish Moodalbail
286e91bba0SGirish Moodalbail #include <stdio.h>
296e91bba0SGirish Moodalbail #include <stdlib.h>
306e91bba0SGirish Moodalbail #include <string.h>
316e91bba0SGirish Moodalbail #include <errno.h>
326e91bba0SGirish Moodalbail #include <fcntl.h>
336e91bba0SGirish Moodalbail #include <unistd.h>
346e91bba0SGirish Moodalbail #include <stropts.h>
356e91bba0SGirish Moodalbail #include <sys/sockio.h>
366e91bba0SGirish Moodalbail #include <sys/types.h>
376e91bba0SGirish Moodalbail #include <sys/stat.h>
386e91bba0SGirish Moodalbail #include <sys/socket.h>
396e91bba0SGirish Moodalbail #include <net/route.h>
406e91bba0SGirish Moodalbail #include <netinet/in.h>
416e91bba0SGirish Moodalbail #include <inet/ip.h>
426e91bba0SGirish Moodalbail #include <arpa/inet.h>
436e91bba0SGirish Moodalbail #include <libintl.h>
446e91bba0SGirish Moodalbail #include <libdlpi.h>
456e91bba0SGirish Moodalbail #include <libinetutil.h>
466e91bba0SGirish Moodalbail #include <libdladm.h>
476e91bba0SGirish Moodalbail #include <libdllink.h>
486e91bba0SGirish Moodalbail #include <libdliptun.h>
496e91bba0SGirish Moodalbail #include <strings.h>
506e91bba0SGirish Moodalbail #include <zone.h>
516e91bba0SGirish Moodalbail #include <ctype.h>
526e91bba0SGirish Moodalbail #include <limits.h>
536e91bba0SGirish Moodalbail #include <assert.h>
546e91bba0SGirish Moodalbail #include <netdb.h>
556e91bba0SGirish Moodalbail #include <pwd.h>
566e91bba0SGirish Moodalbail #include <auth_attr.h>
576e91bba0SGirish Moodalbail #include <secdb.h>
586e91bba0SGirish Moodalbail #include <nss_dbdefs.h>
596e91bba0SGirish Moodalbail #include "libipadm_impl.h"
606e91bba0SGirish Moodalbail
616e91bba0SGirish Moodalbail /* error codes and text description */
626e91bba0SGirish Moodalbail static struct ipadm_error_info {
636e91bba0SGirish Moodalbail ipadm_status_t error_code;
646e91bba0SGirish Moodalbail const char *error_desc;
656e91bba0SGirish Moodalbail } ipadm_errors[] = {
666e91bba0SGirish Moodalbail { IPADM_SUCCESS, "Operation succeeded" },
676e91bba0SGirish Moodalbail { IPADM_FAILURE, "Operation failed" },
686e91bba0SGirish Moodalbail { IPADM_EAUTH, "Insufficient user authorizations" },
696e91bba0SGirish Moodalbail { IPADM_EPERM, "Permission denied" },
706e91bba0SGirish Moodalbail { IPADM_NO_BUFS, "No buffer space available" },
716e91bba0SGirish Moodalbail { IPADM_NO_MEMORY, "Insufficient memory" },
726e91bba0SGirish Moodalbail { IPADM_BAD_ADDR, "Invalid address" },
736e91bba0SGirish Moodalbail { IPADM_BAD_PROTOCOL, "Incorrect protocol family for operation" },
746e91bba0SGirish Moodalbail { IPADM_DAD_FOUND, "Duplicate address detected" },
756e91bba0SGirish Moodalbail { IPADM_EXISTS, "Already exists" },
766e91bba0SGirish Moodalbail { IPADM_IF_EXISTS, "Interface already exists" },
776e91bba0SGirish Moodalbail { IPADM_ADDROBJ_EXISTS, "Address object already exists" },
786e91bba0SGirish Moodalbail { IPADM_ADDRCONF_EXISTS, "Addrconf already in progress" },
796e91bba0SGirish Moodalbail { IPADM_ENXIO, "Interface does not exist" },
806e91bba0SGirish Moodalbail { IPADM_GRP_NOTEMPTY, "IPMP group is not empty" },
816e91bba0SGirish Moodalbail { IPADM_INVALID_ARG, "Invalid argument provided" },
826e91bba0SGirish Moodalbail { IPADM_INVALID_NAME, "Invalid name" },
836e91bba0SGirish Moodalbail { IPADM_DLPI_FAILURE, "Could not open DLPI link" },
846e91bba0SGirish Moodalbail { IPADM_DLADM_FAILURE, "Datalink does not exist" },
856e91bba0SGirish Moodalbail { IPADM_PROP_UNKNOWN, "Unknown property" },
866e91bba0SGirish Moodalbail { IPADM_ERANGE, "Value is outside the allowed range" },
876e91bba0SGirish Moodalbail { IPADM_ESRCH, "Value does not exist" },
886e91bba0SGirish Moodalbail { IPADM_EOVERFLOW, "Number of values exceeds the allowed limit" },
896e91bba0SGirish Moodalbail { IPADM_NOTFOUND, "Object not found" },
906e91bba0SGirish Moodalbail { IPADM_IF_INUSE, "Interface already in use" },
916e91bba0SGirish Moodalbail { IPADM_ADDR_INUSE, "Address already in use" },
926e91bba0SGirish Moodalbail { IPADM_BAD_HOSTNAME, "Hostname maps to multiple IP addresses" },
936e91bba0SGirish Moodalbail { IPADM_ADDR_NOTAVAIL, "Can't assign requested address" },
946e91bba0SGirish Moodalbail { IPADM_ALL_ADDRS_NOT_ENABLED, "All addresses could not be enabled" },
956e91bba0SGirish Moodalbail { IPADM_NDPD_NOT_RUNNING, "IPv6 autoconf daemon in.ndpd not running" },
966e91bba0SGirish Moodalbail { IPADM_DHCP_START_ERROR, "Could not start dhcpagent" },
976e91bba0SGirish Moodalbail { IPADM_DHCP_IPC_ERROR, "Could not communicate with dhcpagent" },
986e91bba0SGirish Moodalbail { IPADM_DHCP_IPC_TIMEOUT, "Communication with dhcpagent timed out" },
996e91bba0SGirish Moodalbail { IPADM_TEMPORARY_OBJ, "Persistent operation on temporary object" },
1006e91bba0SGirish Moodalbail { IPADM_IPC_ERROR, "Could not communicate with ipmgmtd" },
1016e91bba0SGirish Moodalbail { IPADM_NOTSUP, "Operation not supported" },
1026e91bba0SGirish Moodalbail { IPADM_OP_DISABLE_OBJ, "Operation not supported on disabled object" },
103550b6e40SSowmini Varadhan { IPADM_EBADE, "Invalid data exchange with daemon" },
104550b6e40SSowmini Varadhan { IPADM_GZ_PERM, "Operation not permitted on from-gz interface"}
1056e91bba0SGirish Moodalbail };
1066e91bba0SGirish Moodalbail
1076e91bba0SGirish Moodalbail #define IPADM_NUM_ERRORS (sizeof (ipadm_errors) / sizeof (*ipadm_errors))
1086e91bba0SGirish Moodalbail
1096e91bba0SGirish Moodalbail ipadm_status_t
ipadm_errno2status(int error)1106e91bba0SGirish Moodalbail ipadm_errno2status(int error)
1116e91bba0SGirish Moodalbail {
1126e91bba0SGirish Moodalbail switch (error) {
1136e91bba0SGirish Moodalbail case 0:
1146e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
1156e91bba0SGirish Moodalbail case ENXIO:
1166e91bba0SGirish Moodalbail return (IPADM_ENXIO);
1176e91bba0SGirish Moodalbail case ENOMEM:
1186e91bba0SGirish Moodalbail return (IPADM_NO_MEMORY);
1196e91bba0SGirish Moodalbail case ENOBUFS:
1206e91bba0SGirish Moodalbail return (IPADM_NO_BUFS);
1216e91bba0SGirish Moodalbail case EINVAL:
1226e91bba0SGirish Moodalbail return (IPADM_INVALID_ARG);
1236e91bba0SGirish Moodalbail case EBUSY:
1246e91bba0SGirish Moodalbail return (IPADM_IF_INUSE);
1256e91bba0SGirish Moodalbail case EEXIST:
1266e91bba0SGirish Moodalbail return (IPADM_EXISTS);
1276e91bba0SGirish Moodalbail case EADDRNOTAVAIL:
1286e91bba0SGirish Moodalbail return (IPADM_ADDR_NOTAVAIL);
1296e91bba0SGirish Moodalbail case EADDRINUSE:
1306e91bba0SGirish Moodalbail return (IPADM_ADDR_INUSE);
1316e91bba0SGirish Moodalbail case ENOENT:
1326e91bba0SGirish Moodalbail return (IPADM_NOTFOUND);
1336e91bba0SGirish Moodalbail case ERANGE:
1346e91bba0SGirish Moodalbail return (IPADM_ERANGE);
1356e91bba0SGirish Moodalbail case EPERM:
1366e91bba0SGirish Moodalbail return (IPADM_EPERM);
1376e91bba0SGirish Moodalbail case ENOTSUP:
1386e91bba0SGirish Moodalbail case EOPNOTSUPP:
1396e91bba0SGirish Moodalbail return (IPADM_NOTSUP);
1406e91bba0SGirish Moodalbail case EBADF:
1416e91bba0SGirish Moodalbail return (IPADM_IPC_ERROR);
1426e91bba0SGirish Moodalbail case EBADE:
1436e91bba0SGirish Moodalbail return (IPADM_EBADE);
1446e91bba0SGirish Moodalbail case ESRCH:
1456e91bba0SGirish Moodalbail return (IPADM_ESRCH);
1466e91bba0SGirish Moodalbail case EOVERFLOW:
1476e91bba0SGirish Moodalbail return (IPADM_EOVERFLOW);
1486e91bba0SGirish Moodalbail default:
1496e91bba0SGirish Moodalbail return (IPADM_FAILURE);
1506e91bba0SGirish Moodalbail }
1516e91bba0SGirish Moodalbail }
1526e91bba0SGirish Moodalbail
1536e91bba0SGirish Moodalbail /*
1546e91bba0SGirish Moodalbail * Returns a message string for the given libipadm error status.
1556e91bba0SGirish Moodalbail */
1566e91bba0SGirish Moodalbail const char *
ipadm_status2str(ipadm_status_t status)1576e91bba0SGirish Moodalbail ipadm_status2str(ipadm_status_t status)
1586e91bba0SGirish Moodalbail {
1596e91bba0SGirish Moodalbail int i;
1606e91bba0SGirish Moodalbail
1616e91bba0SGirish Moodalbail for (i = 0; i < IPADM_NUM_ERRORS; i++) {
1626e91bba0SGirish Moodalbail if (status == ipadm_errors[i].error_code)
1636e91bba0SGirish Moodalbail return (dgettext(TEXT_DOMAIN,
1646e91bba0SGirish Moodalbail ipadm_errors[i].error_desc));
1656e91bba0SGirish Moodalbail }
1666e91bba0SGirish Moodalbail
1676e91bba0SGirish Moodalbail return (dgettext(TEXT_DOMAIN, "<unknown error>"));
1686e91bba0SGirish Moodalbail }
1696e91bba0SGirish Moodalbail
1706e91bba0SGirish Moodalbail /*
1716e91bba0SGirish Moodalbail * Opens a handle to libipadm.
1726e91bba0SGirish Moodalbail * Possible values for flags:
1736e91bba0SGirish Moodalbail * IPH_VRRP: Used by VRRP daemon to set the socket option SO_VRRP.
1746e91bba0SGirish Moodalbail * IPH_LEGACY: This is used whenever an application needs to provide a
1756e91bba0SGirish Moodalbail * logical interface name while creating or deleting
1766e91bba0SGirish Moodalbail * interfaces and static addresses.
1776e91bba0SGirish Moodalbail * IPH_INIT: Used by ipadm_init_prop(), to initialize protocol properties
1786e91bba0SGirish Moodalbail * on reboot.
1796e91bba0SGirish Moodalbail */
1806e91bba0SGirish Moodalbail ipadm_status_t
ipadm_open(ipadm_handle_t * handle,uint32_t flags)1816e91bba0SGirish Moodalbail ipadm_open(ipadm_handle_t *handle, uint32_t flags)
1826e91bba0SGirish Moodalbail {
1836e91bba0SGirish Moodalbail ipadm_handle_t iph;
1846e91bba0SGirish Moodalbail ipadm_status_t status = IPADM_SUCCESS;
1856e91bba0SGirish Moodalbail zoneid_t zoneid;
1866e91bba0SGirish Moodalbail ushort_t zflags;
1876e91bba0SGirish Moodalbail int on = B_TRUE;
1886e91bba0SGirish Moodalbail
1896e91bba0SGirish Moodalbail if (handle == NULL)
1906e91bba0SGirish Moodalbail return (IPADM_INVALID_ARG);
1916e91bba0SGirish Moodalbail *handle = NULL;
1926e91bba0SGirish Moodalbail
193550b6e40SSowmini Varadhan if (flags & ~(IPH_VRRP|IPH_LEGACY|IPH_INIT|IPH_IPMGMTD))
1946e91bba0SGirish Moodalbail return (IPADM_INVALID_ARG);
1956e91bba0SGirish Moodalbail
1966e91bba0SGirish Moodalbail if ((iph = calloc(1, sizeof (struct ipadm_handle))) == NULL)
1976e91bba0SGirish Moodalbail return (IPADM_NO_MEMORY);
1986e91bba0SGirish Moodalbail iph->iph_sock = -1;
1996e91bba0SGirish Moodalbail iph->iph_sock6 = -1;
2006e91bba0SGirish Moodalbail iph->iph_door_fd = -1;
201550b6e40SSowmini Varadhan iph->iph_rtsock = -1;
2026e91bba0SGirish Moodalbail iph->iph_flags = flags;
2036e91bba0SGirish Moodalbail (void) pthread_mutex_init(&iph->iph_lock, NULL);
2046e91bba0SGirish Moodalbail
2056e91bba0SGirish Moodalbail if ((iph->iph_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ||
2066e91bba0SGirish Moodalbail (iph->iph_sock6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
2076e91bba0SGirish Moodalbail goto errnofail;
2086e91bba0SGirish Moodalbail }
2096e91bba0SGirish Moodalbail
2106e91bba0SGirish Moodalbail /*
2116e91bba0SGirish Moodalbail * We open a handle to libdladm here, to facilitate some daemons (like
2126e91bba0SGirish Moodalbail * nwamd) which opens handle to libipadm before devfsadmd installs the
2136e91bba0SGirish Moodalbail * right device permissions into the kernel and requires "all"
2146e91bba0SGirish Moodalbail * privileges to open DLD_CONTROL_DEV.
2156e91bba0SGirish Moodalbail *
2166e91bba0SGirish Moodalbail * In a non-global shared-ip zone there will be no DLD_CONTROL_DEV node
2176e91bba0SGirish Moodalbail * and dladm_open() will fail. So, we avoid this by not calling
2186e91bba0SGirish Moodalbail * dladm_open() for such zones.
2196e91bba0SGirish Moodalbail */
2206e91bba0SGirish Moodalbail zoneid = getzoneid();
221550b6e40SSowmini Varadhan iph->iph_zoneid = zoneid;
2226e91bba0SGirish Moodalbail if (zoneid != GLOBAL_ZONEID) {
2236e91bba0SGirish Moodalbail if (zone_getattr(zoneid, ZONE_ATTR_FLAGS, &zflags,
2246e91bba0SGirish Moodalbail sizeof (zflags)) < 0) {
2256e91bba0SGirish Moodalbail goto errnofail;
2266e91bba0SGirish Moodalbail }
2276e91bba0SGirish Moodalbail }
2286e91bba0SGirish Moodalbail if ((zoneid == GLOBAL_ZONEID) || (zflags & ZF_NET_EXCL)) {
2296e91bba0SGirish Moodalbail if (dladm_open(&iph->iph_dlh) != DLADM_STATUS_OK) {
2306e91bba0SGirish Moodalbail ipadm_close(iph);
2316e91bba0SGirish Moodalbail return (IPADM_DLADM_FAILURE);
2326e91bba0SGirish Moodalbail }
233550b6e40SSowmini Varadhan if (zoneid != GLOBAL_ZONEID) {
234550b6e40SSowmini Varadhan iph->iph_rtsock = socket(PF_ROUTE, SOCK_RAW, 0);
235550b6e40SSowmini Varadhan /*
236550b6e40SSowmini Varadhan * Failure to open rtsock is ignored as this is
237550b6e40SSowmini Varadhan * only used in non-global zones to initialize
238550b6e40SSowmini Varadhan * routing socket information.
239550b6e40SSowmini Varadhan */
240550b6e40SSowmini Varadhan }
2416e91bba0SGirish Moodalbail } else {
2426e91bba0SGirish Moodalbail assert(zoneid != GLOBAL_ZONEID);
2436e91bba0SGirish Moodalbail iph->iph_dlh = NULL;
2446e91bba0SGirish Moodalbail }
2456e91bba0SGirish Moodalbail if (flags & IPH_VRRP) {
2466e91bba0SGirish Moodalbail if (setsockopt(iph->iph_sock6, SOL_SOCKET, SO_VRRP, &on,
2476e91bba0SGirish Moodalbail sizeof (on)) < 0 || setsockopt(iph->iph_sock, SOL_SOCKET,
2486e91bba0SGirish Moodalbail SO_VRRP, &on, sizeof (on)) < 0) {
2496e91bba0SGirish Moodalbail goto errnofail;
2506e91bba0SGirish Moodalbail }
2516e91bba0SGirish Moodalbail }
2526e91bba0SGirish Moodalbail *handle = iph;
2536e91bba0SGirish Moodalbail return (status);
2546e91bba0SGirish Moodalbail
2556e91bba0SGirish Moodalbail errnofail:
2566e91bba0SGirish Moodalbail status = ipadm_errno2status(errno);
2576e91bba0SGirish Moodalbail ipadm_close(iph);
2586e91bba0SGirish Moodalbail return (status);
2596e91bba0SGirish Moodalbail }
2606e91bba0SGirish Moodalbail
2616e91bba0SGirish Moodalbail /*
2626e91bba0SGirish Moodalbail * Closes and frees the libipadm handle.
2636e91bba0SGirish Moodalbail */
2646e91bba0SGirish Moodalbail void
ipadm_close(ipadm_handle_t iph)2656e91bba0SGirish Moodalbail ipadm_close(ipadm_handle_t iph)
2666e91bba0SGirish Moodalbail {
2676e91bba0SGirish Moodalbail if (iph == NULL)
2686e91bba0SGirish Moodalbail return;
2696e91bba0SGirish Moodalbail if (iph->iph_sock != -1)
2706e91bba0SGirish Moodalbail (void) close(iph->iph_sock);
2716e91bba0SGirish Moodalbail if (iph->iph_sock6 != -1)
2726e91bba0SGirish Moodalbail (void) close(iph->iph_sock6);
273550b6e40SSowmini Varadhan if (iph->iph_rtsock != -1)
274550b6e40SSowmini Varadhan (void) close(iph->iph_rtsock);
2756e91bba0SGirish Moodalbail if (iph->iph_door_fd != -1)
2766e91bba0SGirish Moodalbail (void) close(iph->iph_door_fd);
2776e91bba0SGirish Moodalbail dladm_close(iph->iph_dlh);
2786e91bba0SGirish Moodalbail (void) pthread_mutex_destroy(&iph->iph_lock);
2796e91bba0SGirish Moodalbail free(iph);
2806e91bba0SGirish Moodalbail }
2816e91bba0SGirish Moodalbail
2826e91bba0SGirish Moodalbail /*
2836e91bba0SGirish Moodalbail * Checks if the caller has the authorization to configure network
2846e91bba0SGirish Moodalbail * interfaces.
2856e91bba0SGirish Moodalbail */
2866e91bba0SGirish Moodalbail boolean_t
ipadm_check_auth(void)2876e91bba0SGirish Moodalbail ipadm_check_auth(void)
2886e91bba0SGirish Moodalbail {
2896e91bba0SGirish Moodalbail struct passwd pwd;
2906e91bba0SGirish Moodalbail char buf[NSS_BUFLEN_PASSWD];
2916e91bba0SGirish Moodalbail
2926e91bba0SGirish Moodalbail /* get the password entry for the given user ID */
2936e91bba0SGirish Moodalbail if (getpwuid_r(getuid(), &pwd, buf, sizeof (buf)) == NULL)
2946e91bba0SGirish Moodalbail return (B_FALSE);
2956e91bba0SGirish Moodalbail
2966e91bba0SGirish Moodalbail /* check for presence of given authorization */
2976e91bba0SGirish Moodalbail return (chkauthattr(NETWORK_INTERFACE_CONFIG_AUTH, pwd.pw_name) != 0);
2986e91bba0SGirish Moodalbail }
2996e91bba0SGirish Moodalbail
3006e91bba0SGirish Moodalbail /*
3016e91bba0SGirish Moodalbail * Stores the index value of the interface in `ifname' for the address
3026e91bba0SGirish Moodalbail * family `af' into the buffer pointed to by `index'.
3036e91bba0SGirish Moodalbail */
3046e91bba0SGirish Moodalbail static ipadm_status_t
i_ipadm_get_index(ipadm_handle_t iph,const char * ifname,sa_family_t af,int * index)3056e91bba0SGirish Moodalbail i_ipadm_get_index(ipadm_handle_t iph, const char *ifname, sa_family_t af,
3066e91bba0SGirish Moodalbail int *index)
3076e91bba0SGirish Moodalbail {
3086e91bba0SGirish Moodalbail struct lifreq lifr;
3096e91bba0SGirish Moodalbail int sock;
3106e91bba0SGirish Moodalbail
3116e91bba0SGirish Moodalbail bzero(&lifr, sizeof (lifr));
3126e91bba0SGirish Moodalbail (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
3136e91bba0SGirish Moodalbail if (af == AF_INET)
3146e91bba0SGirish Moodalbail sock = iph->iph_sock;
3156e91bba0SGirish Moodalbail else
3166e91bba0SGirish Moodalbail sock = iph->iph_sock6;
3176e91bba0SGirish Moodalbail
3186e91bba0SGirish Moodalbail if (ioctl(sock, SIOCGLIFINDEX, (caddr_t)&lifr) < 0)
3196e91bba0SGirish Moodalbail return (ipadm_errno2status(errno));
3206e91bba0SGirish Moodalbail *index = lifr.lifr_index;
3216e91bba0SGirish Moodalbail
3226e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
3236e91bba0SGirish Moodalbail }
3246e91bba0SGirish Moodalbail
3256e91bba0SGirish Moodalbail /*
3266e91bba0SGirish Moodalbail * Maximum amount of time (in milliseconds) to wait for Duplicate Address
3276e91bba0SGirish Moodalbail * Detection to complete in the kernel.
3286e91bba0SGirish Moodalbail */
3296e91bba0SGirish Moodalbail #define DAD_WAIT_TIME 1000
3306e91bba0SGirish Moodalbail
3316e91bba0SGirish Moodalbail /*
3326e91bba0SGirish Moodalbail * Any time that flags are changed on an interface where either the new or the
3336e91bba0SGirish Moodalbail * existing flags have IFF_UP set, we'll get a RTM_NEWADDR message to
3346e91bba0SGirish Moodalbail * announce the new address added and its flag status.
3356e91bba0SGirish Moodalbail * We wait here for that message and look for IFF_UP.
3366e91bba0SGirish Moodalbail * If something's amiss with the kernel, though, we don't wait forever.
3376e91bba0SGirish Moodalbail * (Note that IFF_DUPLICATE is a high-order bit, and we cannot see
3386e91bba0SGirish Moodalbail * it in the routing socket messages.)
3396e91bba0SGirish Moodalbail */
3406e91bba0SGirish Moodalbail static ipadm_status_t
i_ipadm_dad_wait(ipadm_handle_t handle,const char * lifname,sa_family_t af,int rtsock)3416e91bba0SGirish Moodalbail i_ipadm_dad_wait(ipadm_handle_t handle, const char *lifname, sa_family_t af,
3426e91bba0SGirish Moodalbail int rtsock)
3436e91bba0SGirish Moodalbail {
3446e91bba0SGirish Moodalbail struct pollfd fds[1];
3456e91bba0SGirish Moodalbail union {
3466e91bba0SGirish Moodalbail struct if_msghdr ifm;
3476e91bba0SGirish Moodalbail char buf[1024];
3486e91bba0SGirish Moodalbail } msg;
3496e91bba0SGirish Moodalbail int index;
3506e91bba0SGirish Moodalbail ipadm_status_t retv;
3516e91bba0SGirish Moodalbail uint64_t flags;
3526e91bba0SGirish Moodalbail hrtime_t starttime, now;
3536e91bba0SGirish Moodalbail
3546e91bba0SGirish Moodalbail fds[0].fd = rtsock;
3556e91bba0SGirish Moodalbail fds[0].events = POLLIN;
3566e91bba0SGirish Moodalbail fds[0].revents = 0;
3576e91bba0SGirish Moodalbail
3586e91bba0SGirish Moodalbail retv = i_ipadm_get_index(handle, lifname, af, &index);
3596e91bba0SGirish Moodalbail if (retv != IPADM_SUCCESS)
3606e91bba0SGirish Moodalbail return (retv);
3616e91bba0SGirish Moodalbail
3626e91bba0SGirish Moodalbail starttime = gethrtime();
3636e91bba0SGirish Moodalbail for (;;) {
3646e91bba0SGirish Moodalbail now = gethrtime();
3656e91bba0SGirish Moodalbail now = (now - starttime) / 1000000;
3666e91bba0SGirish Moodalbail if (now >= DAD_WAIT_TIME)
3676e91bba0SGirish Moodalbail break;
3686e91bba0SGirish Moodalbail if (poll(fds, 1, DAD_WAIT_TIME - (int)now) <= 0)
3696e91bba0SGirish Moodalbail break;
3706e91bba0SGirish Moodalbail if (read(rtsock, &msg, sizeof (msg)) <= 0)
3716e91bba0SGirish Moodalbail break;
3726e91bba0SGirish Moodalbail if (msg.ifm.ifm_type != RTM_NEWADDR)
3736e91bba0SGirish Moodalbail continue;
3746e91bba0SGirish Moodalbail /* Note that ifm_index is just 16 bits */
3756e91bba0SGirish Moodalbail if (index == msg.ifm.ifm_index && (msg.ifm.ifm_flags & IFF_UP))
3766e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
3776e91bba0SGirish Moodalbail }
3786e91bba0SGirish Moodalbail
3796e91bba0SGirish Moodalbail retv = i_ipadm_get_flags(handle, lifname, af, &flags);
3806e91bba0SGirish Moodalbail if (retv != IPADM_SUCCESS)
3816e91bba0SGirish Moodalbail return (retv);
3826e91bba0SGirish Moodalbail if (flags & IFF_DUPLICATE)
3836e91bba0SGirish Moodalbail return (IPADM_DAD_FOUND);
3846e91bba0SGirish Moodalbail
3856e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
3866e91bba0SGirish Moodalbail }
3876e91bba0SGirish Moodalbail
3886e91bba0SGirish Moodalbail /*
3896e91bba0SGirish Moodalbail * Sets the flags `on_flags' and resets the flags `off_flags' for the logical
3906e91bba0SGirish Moodalbail * interface in `lifname'.
3916e91bba0SGirish Moodalbail *
3926e91bba0SGirish Moodalbail * If the new flags value will transition the interface from "down" to "up"
3936e91bba0SGirish Moodalbail * then duplicate address detection is performed by the kernel. This routine
3946e91bba0SGirish Moodalbail * waits to get the outcome of that test.
3956e91bba0SGirish Moodalbail */
3966e91bba0SGirish Moodalbail ipadm_status_t
i_ipadm_set_flags(ipadm_handle_t iph,const char * lifname,sa_family_t af,uint64_t on_flags,uint64_t off_flags)3976e91bba0SGirish Moodalbail i_ipadm_set_flags(ipadm_handle_t iph, const char *lifname, sa_family_t af,
3986e91bba0SGirish Moodalbail uint64_t on_flags, uint64_t off_flags)
3996e91bba0SGirish Moodalbail {
4006e91bba0SGirish Moodalbail struct lifreq lifr;
4016e91bba0SGirish Moodalbail uint64_t oflags;
4026e91bba0SGirish Moodalbail ipadm_status_t ret;
4036e91bba0SGirish Moodalbail int rtsock = -1;
4046e91bba0SGirish Moodalbail int sock, err;
4056e91bba0SGirish Moodalbail
4066e91bba0SGirish Moodalbail ret = i_ipadm_get_flags(iph, lifname, af, &oflags);
4076e91bba0SGirish Moodalbail if (ret != IPADM_SUCCESS)
4086e91bba0SGirish Moodalbail return (ret);
4096e91bba0SGirish Moodalbail
4106e91bba0SGirish Moodalbail sock = (af == AF_INET ? iph->iph_sock : iph->iph_sock6);
4116e91bba0SGirish Moodalbail
4126e91bba0SGirish Moodalbail /*
4136e91bba0SGirish Moodalbail * Any time flags are changed on an interface that has IFF_UP set,
4146e91bba0SGirish Moodalbail * we get a routing socket message. We care about the status,
4156e91bba0SGirish Moodalbail * though, only when the new flags are marked "up."
4166e91bba0SGirish Moodalbail */
4176e91bba0SGirish Moodalbail if (!(oflags & IFF_UP) && (on_flags & IFF_UP))
4186e91bba0SGirish Moodalbail rtsock = socket(PF_ROUTE, SOCK_RAW, af);
4196e91bba0SGirish Moodalbail
4206e91bba0SGirish Moodalbail oflags |= on_flags;
4216e91bba0SGirish Moodalbail oflags &= ~off_flags;
4226e91bba0SGirish Moodalbail bzero(&lifr, sizeof (lifr));
4236e91bba0SGirish Moodalbail (void) strlcpy(lifr.lifr_name, lifname, sizeof (lifr.lifr_name));
4246e91bba0SGirish Moodalbail lifr.lifr_flags = oflags;
4256e91bba0SGirish Moodalbail if (ioctl(sock, SIOCSLIFFLAGS, (caddr_t)&lifr) < 0) {
4266e91bba0SGirish Moodalbail err = errno;
4276e91bba0SGirish Moodalbail if (rtsock != -1)
4286e91bba0SGirish Moodalbail (void) close(rtsock);
4296e91bba0SGirish Moodalbail return (ipadm_errno2status(err));
4306e91bba0SGirish Moodalbail }
4316e91bba0SGirish Moodalbail if (rtsock == -1) {
4326e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
4336e91bba0SGirish Moodalbail } else {
4346e91bba0SGirish Moodalbail /* Wait for DAD to complete. */
4356e91bba0SGirish Moodalbail ret = i_ipadm_dad_wait(iph, lifname, af, rtsock);
4366e91bba0SGirish Moodalbail (void) close(rtsock);
4376e91bba0SGirish Moodalbail return (ret);
4386e91bba0SGirish Moodalbail }
4396e91bba0SGirish Moodalbail }
4406e91bba0SGirish Moodalbail
4416e91bba0SGirish Moodalbail /*
4426e91bba0SGirish Moodalbail * Returns the flags value for the logical interface in `lifname'
4436e91bba0SGirish Moodalbail * in the buffer pointed to by `flags'.
4446e91bba0SGirish Moodalbail */
4456e91bba0SGirish Moodalbail ipadm_status_t
i_ipadm_get_flags(ipadm_handle_t iph,const char * lifname,sa_family_t af,uint64_t * flags)4466e91bba0SGirish Moodalbail i_ipadm_get_flags(ipadm_handle_t iph, const char *lifname, sa_family_t af,
4476e91bba0SGirish Moodalbail uint64_t *flags)
4486e91bba0SGirish Moodalbail {
4496e91bba0SGirish Moodalbail struct lifreq lifr;
4506e91bba0SGirish Moodalbail int sock;
4516e91bba0SGirish Moodalbail
4526e91bba0SGirish Moodalbail bzero(&lifr, sizeof (lifr));
4536e91bba0SGirish Moodalbail (void) strlcpy(lifr.lifr_name, lifname, sizeof (lifr.lifr_name));
4546e91bba0SGirish Moodalbail if (af == AF_INET)
4556e91bba0SGirish Moodalbail sock = iph->iph_sock;
4566e91bba0SGirish Moodalbail else
4576e91bba0SGirish Moodalbail sock = iph->iph_sock6;
4586e91bba0SGirish Moodalbail
4596e91bba0SGirish Moodalbail if (ioctl(sock, SIOCGLIFFLAGS, (caddr_t)&lifr) < 0) {
4606e91bba0SGirish Moodalbail return (ipadm_errno2status(errno));
4616e91bba0SGirish Moodalbail }
4626e91bba0SGirish Moodalbail *flags = lifr.lifr_flags;
4636e91bba0SGirish Moodalbail
4646e91bba0SGirish Moodalbail return (IPADM_SUCCESS);
4656e91bba0SGirish Moodalbail }
4666e91bba0SGirish Moodalbail
4676e91bba0SGirish Moodalbail /*
4686e91bba0SGirish Moodalbail * Determines whether or not an interface name represents a loopback
4696e91bba0SGirish Moodalbail * interface, before the interface has been plumbed.
4706e91bba0SGirish Moodalbail * It is assumed that the interface name in `ifname' is of correct format
4716e91bba0SGirish Moodalbail * as verified by ifparse_ifspec().
4726e91bba0SGirish Moodalbail *
4736e91bba0SGirish Moodalbail * Returns: B_TRUE if loopback, B_FALSE if not.
4746e91bba0SGirish Moodalbail */
4756e91bba0SGirish Moodalbail boolean_t
i_ipadm_is_loopback(const char * ifname)4766e91bba0SGirish Moodalbail i_ipadm_is_loopback(const char *ifname)
4776e91bba0SGirish Moodalbail {
4786e91bba0SGirish Moodalbail int len = strlen(LOOPBACK_IF);
4796e91bba0SGirish Moodalbail
4806e91bba0SGirish Moodalbail return (strncmp(ifname, LOOPBACK_IF, len) == 0 &&
4816e91bba0SGirish Moodalbail (ifname[len] == '\0' || ifname[len] == IPADM_LOGICAL_SEP));
4826e91bba0SGirish Moodalbail }
4836e91bba0SGirish Moodalbail
4846e91bba0SGirish Moodalbail /*
4856e91bba0SGirish Moodalbail * Determines whether or not an interface name represents a vni
4866e91bba0SGirish Moodalbail * interface, before the interface has been plumbed.
4876e91bba0SGirish Moodalbail * It is assumed that the interface name in `ifname' is of correct format
4886e91bba0SGirish Moodalbail * as verified by ifparse_ifspec().
4896e91bba0SGirish Moodalbail *
4906e91bba0SGirish Moodalbail * Returns: B_TRUE if vni, B_FALSE if not.
4916e91bba0SGirish Moodalbail */
4926e91bba0SGirish Moodalbail boolean_t
i_ipadm_is_vni(const char * ifname)4936e91bba0SGirish Moodalbail i_ipadm_is_vni(const char *ifname)
4946e91bba0SGirish Moodalbail {
4956e91bba0SGirish Moodalbail ifspec_t ifsp;
4966e91bba0SGirish Moodalbail
4976e91bba0SGirish Moodalbail return (ifparse_ifspec(ifname, &ifsp) &&
4986e91bba0SGirish Moodalbail strcmp(ifsp.ifsp_devnm, "vni") == 0);
4996e91bba0SGirish Moodalbail }
5006e91bba0SGirish Moodalbail
5016e91bba0SGirish Moodalbail /*
5026e91bba0SGirish Moodalbail * Returns B_TRUE if `ifname' is an IP interface on a 6to4 tunnel.
5036e91bba0SGirish Moodalbail */
5046e91bba0SGirish Moodalbail boolean_t
i_ipadm_is_6to4(ipadm_handle_t iph,char * ifname)5056e91bba0SGirish Moodalbail i_ipadm_is_6to4(ipadm_handle_t iph, char *ifname)
5066e91bba0SGirish Moodalbail {
5076e91bba0SGirish Moodalbail dladm_status_t dlstatus;
5086e91bba0SGirish Moodalbail datalink_class_t class;
5096e91bba0SGirish Moodalbail iptun_params_t params;
5106e91bba0SGirish Moodalbail datalink_id_t linkid;
5116e91bba0SGirish Moodalbail
5126e91bba0SGirish Moodalbail if (iph->iph_dlh == NULL) {
513550b6e40SSowmini Varadhan assert(iph->iph_zoneid != GLOBAL_ZONEID);
5146e91bba0SGirish Moodalbail return (B_FALSE);
5156e91bba0SGirish Moodalbail }
5166e91bba0SGirish Moodalbail dlstatus = dladm_name2info(iph->iph_dlh, ifname, &linkid, NULL,
5176e91bba0SGirish Moodalbail &class, NULL);
5186e91bba0SGirish Moodalbail if (dlstatus == DLADM_STATUS_OK && class == DATALINK_CLASS_IPTUN) {
5196e91bba0SGirish Moodalbail params.iptun_param_linkid = linkid;
5206e91bba0SGirish Moodalbail dlstatus = dladm_iptun_getparams(iph->iph_dlh, ¶ms,
5216e91bba0SGirish Moodalbail DLADM_OPT_ACTIVE);
5226e91bba0SGirish Moodalbail if (dlstatus == DLADM_STATUS_OK &&
5236e91bba0SGirish Moodalbail params.iptun_param_type == IPTUN_TYPE_6TO4) {
5246e91bba0SGirish Moodalbail return (B_TRUE);
5256e91bba0SGirish Moodalbail }
5266e91bba0SGirish Moodalbail }
5276e91bba0SGirish Moodalbail return (B_FALSE);
5286e91bba0SGirish Moodalbail }
5296e91bba0SGirish Moodalbail
5306e91bba0SGirish Moodalbail /*
5316e91bba0SGirish Moodalbail * For a given interface name, ipadm_if_enabled() checks if v4
5326e91bba0SGirish Moodalbail * or v6 or both IP interfaces exist in the active configuration.
5336e91bba0SGirish Moodalbail */
5346e91bba0SGirish Moodalbail boolean_t
ipadm_if_enabled(ipadm_handle_t iph,const char * ifname,sa_family_t af)5356e91bba0SGirish Moodalbail ipadm_if_enabled(ipadm_handle_t iph, const char *ifname, sa_family_t af)
5366e91bba0SGirish Moodalbail {
5376e91bba0SGirish Moodalbail struct lifreq lifr;
5386e91bba0SGirish Moodalbail int s4 = iph->iph_sock;
5396e91bba0SGirish Moodalbail int s6 = iph->iph_sock6;
5406e91bba0SGirish Moodalbail
5416e91bba0SGirish Moodalbail bzero(&lifr, sizeof (lifr));
5426e91bba0SGirish Moodalbail (void) strlcpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
5436e91bba0SGirish Moodalbail switch (af) {
5446e91bba0SGirish Moodalbail case AF_INET:
5456e91bba0SGirish Moodalbail if (ioctl(s4, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0)
5466e91bba0SGirish Moodalbail return (B_TRUE);
5476e91bba0SGirish Moodalbail break;
5486e91bba0SGirish Moodalbail case AF_INET6:
5496e91bba0SGirish Moodalbail if (ioctl(s6, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0)
5506e91bba0SGirish Moodalbail return (B_TRUE);
5516e91bba0SGirish Moodalbail break;
5526e91bba0SGirish Moodalbail case AF_UNSPEC:
5536e91bba0SGirish Moodalbail if (ioctl(s4, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0 ||
5546e91bba0SGirish Moodalbail ioctl(s6, SIOCGLIFFLAGS, (caddr_t)&lifr) == 0) {
5556e91bba0SGirish Moodalbail return (B_TRUE);
5566e91bba0SGirish Moodalbail }
5576e91bba0SGirish Moodalbail }
5586e91bba0SGirish Moodalbail return (B_FALSE);
5596e91bba0SGirish Moodalbail }
5606e91bba0SGirish Moodalbail
5616e91bba0SGirish Moodalbail /*
5626e91bba0SGirish Moodalbail * Apply the interface property by retrieving information from nvl.
5636e91bba0SGirish Moodalbail */
5646e91bba0SGirish Moodalbail static ipadm_status_t
i_ipadm_init_ifprop(ipadm_handle_t iph,nvlist_t * nvl)5656e91bba0SGirish Moodalbail i_ipadm_init_ifprop(ipadm_handle_t iph, nvlist_t *nvl)
5666e91bba0SGirish Moodalbail {
5676e91bba0SGirish Moodalbail nvpair_t *nvp;
5686e91bba0SGirish Moodalbail char *name, *pname = NULL;
5696e91bba0SGirish Moodalbail char *protostr = NULL, *ifname = NULL, *pval = NULL;
5706e91bba0SGirish Moodalbail uint_t proto;
5716e91bba0SGirish Moodalbail int err = 0;
5726e91bba0SGirish Moodalbail
5736e91bba0SGirish Moodalbail for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
5746e91bba0SGirish Moodalbail nvp = nvlist_next_nvpair(nvl, nvp)) {
5756e91bba0SGirish Moodalbail name = nvpair_name(nvp);
5766e91bba0SGirish Moodalbail if (strcmp(name, IPADM_NVP_IFNAME) == 0) {
5776e91bba0SGirish Moodalbail if ((err = nvpair_value_string(nvp, &ifname)) != 0)
5786e91bba0SGirish Moodalbail break;
5796e91bba0SGirish Moodalbail } else if (strcmp(name, IPADM_NVP_PROTONAME) == 0) {
5806e91bba0SGirish Moodalbail if ((err = nvpair_value_string(nvp, &protostr)) != 0)
5816e91bba0SGirish Moodalbail break;
5826e91bba0SGirish Moodalbail } else {
5836e91bba0SGirish Moodalbail assert(!IPADM_PRIV_NVP(name));
5846e91bba0SGirish Moodalbail pname = name;
5856e91bba0SGirish Moodalbail if ((err = nvpair_value_string(nvp, &pval)) != 0)
5866e91bba0SGirish Moodalbail break;
5876e91bba0SGirish Moodalbail }
5886e91bba0SGirish Moodalbail }
5896e91bba0SGirish Moodalbail if (err != 0)
5906e91bba0SGirish Moodalbail return (ipadm_errno2status(err));
5916e91bba0SGirish Moodalbail proto = ipadm_str2proto(protostr);
5926e91bba0SGirish Moodalbail return (ipadm_set_ifprop(iph, ifname, pname, pval, proto,
5936e91bba0SGirish Moodalbail IPADM_OPT_ACTIVE));
5946e91bba0SGirish Moodalbail }
5956e91bba0SGirish Moodalbail
5966e91bba0SGirish Moodalbail /*
5976e91bba0SGirish Moodalbail * Instantiate the address object or set the address object property by
5986e91bba0SGirish Moodalbail * retrieving the configuration from the nvlist `nvl'.
5996e91bba0SGirish Moodalbail */
6006e91bba0SGirish Moodalbail ipadm_status_t
i_ipadm_init_addrobj(ipadm_handle_t iph,nvlist_t * nvl)6016e91bba0SGirish Moodalbail i_ipadm_init_addrobj(ipadm_handle_t iph, nvlist_t *nvl)
6026e91bba0SGirish Moodalbail {
6036e91bba0SGirish Moodalbail nvpair_t *nvp;
6046e91bba0SGirish Moodalbail char *name;
6056e91bba0SGirish Moodalbail char *aobjname = NULL, *pval = NULL, *ifname = NULL;
6066e91bba0SGirish Moodalbail sa_family_t af = AF_UNSPEC;
6076e91bba0SGirish Moodalbail ipadm_addr_type_t atype = IPADM_ADDR_NONE;
6086e91bba0SGirish Moodalbail int err = 0;
6096e91bba0SGirish Moodalbail ipadm_status_t status = IPADM_SUCCESS;
6106e91bba0SGirish Moodalbail
6116e91bba0SGirish Moodalbail for (nvp = nvlist_next_nvpair(nvl, NULL); nvp != NULL;
6126e91bba0SGirish Moodalbail nvp = nvlist_next_nvpair(nvl, nvp)) {
6136e91bba0SGirish Moodalbail name = nvpair_name(nvp);
6146e91bba0SGirish Moodalbail if (strcmp(name, IPADM_NVP_IFNAME) == 0) {
6156e91bba0SGirish Moodalbail if ((err = nvpair_value_string(nvp, &ifname)) != 0)
6166e91bba0SGirish Moodalbail break;
6176e91bba0SGirish Moodalbail } else if (strcmp(name, IPADM_NVP_AOBJNAME) == 0) {
6186e91bba0SGirish Moodalbail if ((err = nvpair_value_string(nvp, &aobjname)) != 0)
6196e91bba0SGirish Moodalbail break;
6206e91bba0SGirish Moodalbail } else if (i_ipadm_name2atype(name, &af, &atype)) {
6216e91bba0SGirish Moodalbail break;
6226e91bba0SGirish Moodalbail } else {
6236e91bba0SGirish Moodalbail assert(!IPADM_PRIV_NVP(name));
6246e91bba0SGirish Moodalbail err = nvpair_value_string(nvp, &pval);
6256e91bba0SGirish Moodalbail break;
6266e91bba0SGirish Moodalbail }
6276e91bba0SGirish Moodalbail }
6286e91bba0SGirish Moodalbail if (err != 0)
6296e91bba0SGirish Moodalbail return (ipadm_errno2status(err));
6306e91bba0SGirish Moodalbail
6316e91bba0SGirish Moodalbail switch (atype) {
6326e91bba0SGirish Moodalbail case IPADM_ADDR_STATIC:
6336e91bba0SGirish Moodalbail status = i_ipadm_enable_static(iph, ifname, nvl, af);
6346e91bba0SGirish Moodalbail break;
6356e91bba0SGirish Moodalbail case IPADM_ADDR_DHCP:
6366e91bba0SGirish Moodalbail status = i_ipadm_enable_dhcp(iph, ifname, nvl);
6376e91bba0SGirish Moodalbail if (status == IPADM_DHCP_IPC_TIMEOUT)
6386e91bba0SGirish Moodalbail status = IPADM_SUCCESS;
6396e91bba0SGirish Moodalbail break;
6406e91bba0SGirish Moodalbail case IPADM_ADDR_IPV6_ADDRCONF:
6416e91bba0SGirish Moodalbail status = i_ipadm_enable_addrconf(iph, ifname, nvl);
6426e91bba0SGirish Moodalbail break;
6436e91bba0SGirish Moodalbail case IPADM_ADDR_NONE:
6446e91bba0SGirish Moodalbail status = ipadm_set_addrprop(iph, name, pval, aobjname,
6456e91bba0SGirish Moodalbail IPADM_OPT_ACTIVE);
6466e91bba0SGirish Moodalbail break;
6476e91bba0SGirish Moodalbail }
6486e91bba0SGirish Moodalbail
6496e91bba0SGirish Moodalbail return (status);
6506e91bba0SGirish Moodalbail }
6516e91bba0SGirish Moodalbail
6526e91bba0SGirish Moodalbail /*
6536e91bba0SGirish Moodalbail * Instantiate the interface object by retrieving the configuration from
6546e91bba0SGirish Moodalbail * `ifnvl'. The nvlist `ifnvl' contains all the persistent configuration
6556e91bba0SGirish Moodalbail * (interface properties and address objects on that interface) for the
6566e91bba0SGirish Moodalbail * given `ifname'.
6576e91bba0SGirish Moodalbail */
6586e91bba0SGirish Moodalbail ipadm_status_t
i_ipadm_init_ifobj(ipadm_handle_t iph,const char * ifname,nvlist_t * ifnvl)6596e91bba0SGirish Moodalbail i_ipadm_init_ifobj(ipadm_handle_t iph, const char *ifname, nvlist_t *ifnvl)
6606e91bba0SGirish Moodalbail {
6616e91bba0SGirish Moodalbail nvlist_t *nvl = NULL;
6626e91bba0SGirish Moodalbail nvpair_t *nvp;
663a73be61aSHans Rosenfeld ipadm_status_t status = IPADM_ENXIO;
6646e91bba0SGirish Moodalbail ipadm_status_t ret_status = IPADM_SUCCESS;
6656e91bba0SGirish Moodalbail char newifname[LIFNAMSIZ];
6666e91bba0SGirish Moodalbail char *aobjstr;
667a73be61aSHans Rosenfeld uint16_t *afs;
668a73be61aSHans Rosenfeld char *gifname;
669a73be61aSHans Rosenfeld uint_t nelem = 0;
670a73be61aSHans Rosenfeld boolean_t init_from_gz = B_FALSE;
671a73be61aSHans Rosenfeld boolean_t move_to_group = B_FALSE;
6726e91bba0SGirish Moodalbail
6736e91bba0SGirish Moodalbail (void) strlcpy(newifname, ifname, sizeof (newifname));
674a73be61aSHans Rosenfeld
6756e91bba0SGirish Moodalbail /*
676a73be61aSHans Rosenfeld * First go through the ifnvl nvlist looking for nested nvlist
677a73be61aSHans Rosenfeld * containing interface class and address families.
6786e91bba0SGirish Moodalbail */
6796e91bba0SGirish Moodalbail for (nvp = nvlist_next_nvpair(ifnvl, NULL); nvp != NULL;
6806e91bba0SGirish Moodalbail nvp = nvlist_next_nvpair(ifnvl, nvp)) {
681a73be61aSHans Rosenfeld char *icstr;
682a73be61aSHans Rosenfeld char **mifnames;
683a73be61aSHans Rosenfeld uint32_t ipadm_flags = IPADM_OPT_ACTIVE;
684a73be61aSHans Rosenfeld
685a73be61aSHans Rosenfeld if (nvpair_value_nvlist(nvp, &nvl) != 0 ||
686a73be61aSHans Rosenfeld nvlist_lookup_uint16_array(nvl, IPADM_NVP_FAMILIES,
687a73be61aSHans Rosenfeld &afs, &nelem) != 0)
6886e91bba0SGirish Moodalbail continue;
6896e91bba0SGirish Moodalbail
690a73be61aSHans Rosenfeld /* Check if this is IPMP group interface */
691a73be61aSHans Rosenfeld if (nvlist_lookup_string(nvl, IPADM_NVP_IFCLASS,
692a73be61aSHans Rosenfeld &icstr) == 0 && atoi(icstr) == IPADM_IF_CLASS_IPMP)
693a73be61aSHans Rosenfeld ipadm_flags |= IPADM_OPT_IPMP;
694a73be61aSHans Rosenfeld
695a73be61aSHans Rosenfeld /* Create interfaces for address families specified */
696a73be61aSHans Rosenfeld while (nelem-- > 0) {
697a73be61aSHans Rosenfeld uint16_t af = afs[nelem];
698a73be61aSHans Rosenfeld
699a73be61aSHans Rosenfeld assert(af == AF_INET || af == AF_INET6);
700a73be61aSHans Rosenfeld
701a73be61aSHans Rosenfeld status = i_ipadm_plumb_if(iph, newifname, af,
702a73be61aSHans Rosenfeld ipadm_flags);
7036e91bba0SGirish Moodalbail if (status == IPADM_IF_EXISTS)
7046e91bba0SGirish Moodalbail status = IPADM_SUCCESS;
705a73be61aSHans Rosenfeld if (status != IPADM_SUCCESS)
706a73be61aSHans Rosenfeld return (status);
707a73be61aSHans Rosenfeld }
708a73be61aSHans Rosenfeld if (nvlist_lookup_string(nvl, IPADM_NVP_GIFNAME,
709a73be61aSHans Rosenfeld &gifname) == 0) {
710a73be61aSHans Rosenfeld /*
711a73be61aSHans Rosenfeld * IPMP underlying interface. Move to the
712a73be61aSHans Rosenfeld * specified IPMP group.
713a73be61aSHans Rosenfeld */
714a73be61aSHans Rosenfeld move_to_group = B_TRUE;
715a73be61aSHans Rosenfeld } else if ((ipadm_flags & IPADM_OPT_IPMP) &&
716a73be61aSHans Rosenfeld nvlist_lookup_string_array(nvl, IPADM_NVP_MIFNAMES,
717a73be61aSHans Rosenfeld &mifnames, &nelem) == 0) {
718a73be61aSHans Rosenfeld /* Non-empty IPMP group interface */
719a73be61aSHans Rosenfeld while (nelem-- > 0) {
720a73be61aSHans Rosenfeld (void) ipadm_add_ipmp_member(iph, newifname,
721a73be61aSHans Rosenfeld mifnames[nelem], IPADM_OPT_ACTIVE);
722a73be61aSHans Rosenfeld }
723a73be61aSHans Rosenfeld }
724a73be61aSHans Rosenfeld if (iph->iph_zoneid != GLOBAL_ZONEID)
725a73be61aSHans Rosenfeld init_from_gz = B_TRUE;
726a73be61aSHans Rosenfeld }
727550b6e40SSowmini Varadhan
728a73be61aSHans Rosenfeld if (status != IPADM_SUCCESS)
729a73be61aSHans Rosenfeld return (status);
730a73be61aSHans Rosenfeld
731a73be61aSHans Rosenfeld /*
732a73be61aSHans Rosenfeld * Go through the ifnvl nvlist again, applying persistent configuration.
733a73be61aSHans Rosenfeld */
734a73be61aSHans Rosenfeld for (nvp = nvlist_next_nvpair(ifnvl, NULL); nvp != NULL;
735a73be61aSHans Rosenfeld nvp = nvlist_next_nvpair(ifnvl, nvp)) {
736a73be61aSHans Rosenfeld if (nvpair_value_nvlist(nvp, &nvl) != 0)
737a73be61aSHans Rosenfeld continue;
738a73be61aSHans Rosenfeld if (nvlist_lookup_string(nvl, IPADM_NVP_AOBJNAME,
7396e91bba0SGirish Moodalbail &aobjstr) == 0) {
7406e91bba0SGirish Moodalbail /*
741b31320a7SChris Fraire * For addresses, we need to relocate addrprops from the
742b31320a7SChris Fraire * nvlist `ifnvl'.
7436e91bba0SGirish Moodalbail */
7446e91bba0SGirish Moodalbail if (nvlist_exists(nvl, IPADM_NVP_IPV4ADDR) ||
745b31320a7SChris Fraire nvlist_exists(nvl, IPADM_NVP_IPV6ADDR) ||
746b31320a7SChris Fraire nvlist_exists(nvl, IPADM_NVP_DHCP)) {
747b31320a7SChris Fraire status = i_ipadm_merge_addrprops_from_nvl(ifnvl,
7486e91bba0SGirish Moodalbail nvl, aobjstr);
749a73be61aSHans Rosenfeld
7506e91bba0SGirish Moodalbail if (status != IPADM_SUCCESS)
7516e91bba0SGirish Moodalbail continue;
7526e91bba0SGirish Moodalbail }
7536e91bba0SGirish Moodalbail status = i_ipadm_init_addrobj(iph, nvl);
754a73be61aSHans Rosenfeld
7556e91bba0SGirish Moodalbail /*
7566e91bba0SGirish Moodalbail * If this address is in use on some other interface,
7576e91bba0SGirish Moodalbail * we want to record an error to be returned as
7586e91bba0SGirish Moodalbail * a soft error and continue processing the rest of
7596e91bba0SGirish Moodalbail * the addresses.
7606e91bba0SGirish Moodalbail */
7616e91bba0SGirish Moodalbail if (status == IPADM_ADDR_NOTAVAIL) {
7626e91bba0SGirish Moodalbail ret_status = IPADM_ALL_ADDRS_NOT_ENABLED;
7636e91bba0SGirish Moodalbail status = IPADM_SUCCESS;
7646e91bba0SGirish Moodalbail }
765a73be61aSHans Rosenfeld } else if (nvlist_exists(nvl, IPADM_NVP_PROTONAME) == B_TRUE) {
7666e91bba0SGirish Moodalbail status = i_ipadm_init_ifprop(iph, nvl);
7676e91bba0SGirish Moodalbail }
7686e91bba0SGirish Moodalbail if (status != IPADM_SUCCESS)
7696e91bba0SGirish Moodalbail return (status);
7706e91bba0SGirish Moodalbail }
771a73be61aSHans Rosenfeld if (move_to_group) {
772a73be61aSHans Rosenfeld (void) ipadm_add_ipmp_member(iph, gifname, newifname,
773a73be61aSHans Rosenfeld IPADM_OPT_ACTIVE);
774a73be61aSHans Rosenfeld }
775a73be61aSHans Rosenfeld if (init_from_gz)
776550b6e40SSowmini Varadhan ret_status = ipadm_init_net_from_gz(iph, newifname, NULL);
7776e91bba0SGirish Moodalbail return (ret_status);
7786e91bba0SGirish Moodalbail }
7796e91bba0SGirish Moodalbail
7806e91bba0SGirish Moodalbail /*
7816e91bba0SGirish Moodalbail * Retrieves the persistent configuration for the given interface(s) in `ifs'
7826e91bba0SGirish Moodalbail * by contacting the daemon and dumps the information in `allifs'.
7836e91bba0SGirish Moodalbail */
7846e91bba0SGirish Moodalbail ipadm_status_t
i_ipadm_init_ifs(ipadm_handle_t iph,const char * ifs,nvlist_t ** allifs)7856e91bba0SGirish Moodalbail i_ipadm_init_ifs(ipadm_handle_t iph, const char *ifs, nvlist_t **allifs)
7866e91bba0SGirish Moodalbail {
7876e91bba0SGirish Moodalbail nvlist_t *nvl = NULL;
7886e91bba0SGirish Moodalbail size_t nvlsize, bufsize;
7896e91bba0SGirish Moodalbail ipmgmt_initif_arg_t *iargp;
7906e91bba0SGirish Moodalbail char *buf = NULL, *nvlbuf = NULL;
7916e91bba0SGirish Moodalbail ipmgmt_get_rval_t *rvalp = NULL;
7926e91bba0SGirish Moodalbail int err;
7936e91bba0SGirish Moodalbail ipadm_status_t status = IPADM_SUCCESS;
7946e91bba0SGirish Moodalbail
795a73be61aSHans Rosenfeld status = ipadm_str2nvlist(ifs, &nvl, IPADM_NORVAL);
796a73be61aSHans Rosenfeld if (status != IPADM_SUCCESS)
797a73be61aSHans Rosenfeld return (status);
7986e91bba0SGirish Moodalbail
7996e91bba0SGirish Moodalbail err = nvlist_pack(nvl, &nvlbuf, &nvlsize, NV_ENCODE_NATIVE, 0);
8006e91bba0SGirish Moodalbail if (err != 0) {
8016e91bba0SGirish Moodalbail status = ipadm_errno2status(err);
8026e91bba0SGirish Moodalbail goto done;
8036e91bba0SGirish Moodalbail }
8046e91bba0SGirish Moodalbail bufsize = sizeof (*iargp) + nvlsize;
8056e91bba0SGirish Moodalbail if ((buf = malloc(bufsize)) == NULL) {
8066e91bba0SGirish Moodalbail status = ipadm_errno2status(errno);
8076e91bba0SGirish Moodalbail goto done;
8086e91bba0SGirish Moodalbail }
8096e91bba0SGirish Moodalbail
8106e91bba0SGirish Moodalbail /* populate the door_call argument structure */
8116e91bba0SGirish Moodalbail iargp = (void *)buf;
8126e91bba0SGirish Moodalbail iargp->ia_cmd = IPMGMT_CMD_INITIF;
8136e91bba0SGirish Moodalbail iargp->ia_flags = 0;
8146e91bba0SGirish Moodalbail iargp->ia_family = AF_UNSPEC;
8156e91bba0SGirish Moodalbail iargp->ia_nvlsize = nvlsize;
8166e91bba0SGirish Moodalbail (void) bcopy(nvlbuf, buf + sizeof (*iargp), nvlsize);
8176e91bba0SGirish Moodalbail
8186e91bba0SGirish Moodalbail if ((rvalp = malloc(sizeof (ipmgmt_get_rval_t))) == NULL) {
8196e91bba0SGirish Moodalbail status = ipadm_errno2status(errno);
8206e91bba0SGirish Moodalbail goto done;
8216e91bba0SGirish Moodalbail }
8226e91bba0SGirish Moodalbail if ((err = ipadm_door_call(iph, iargp, bufsize, (void **)&rvalp,
8236e91bba0SGirish Moodalbail sizeof (*rvalp), B_TRUE)) != 0) {
8246e91bba0SGirish Moodalbail status = ipadm_errno2status(err);
8256e91bba0SGirish Moodalbail goto done;
8266e91bba0SGirish Moodalbail }
8276e91bba0SGirish Moodalbail
8286e91bba0SGirish Moodalbail /*
829ad69a334SYuri Pankov * Daemon reply pointed to by rvalp contains ipmgmt_get_rval_t structure
830ad69a334SYuri Pankov * followed by a list of packed nvlists, each of which represents
831ad69a334SYuri Pankov * configuration information for the given interface(s).
8326e91bba0SGirish Moodalbail */
833ad69a334SYuri Pankov err = nvlist_unpack((char *)rvalp + sizeof (ipmgmt_get_rval_t),
8340d1087e8SHans Rosenfeld rvalp->ir_nvlsize, allifs, 0);
8356e91bba0SGirish Moodalbail if (err != 0)
8366e91bba0SGirish Moodalbail status = ipadm_errno2status(err);
8376e91bba0SGirish Moodalbail done:
8386e91bba0SGirish Moodalbail nvlist_free(nvl);
8396e91bba0SGirish Moodalbail free(buf);
8406e91bba0SGirish Moodalbail free(nvlbuf);
8416e91bba0SGirish Moodalbail free(rvalp);
8426e91bba0SGirish Moodalbail return (status);
8436e91bba0SGirish Moodalbail }
8446e91bba0SGirish Moodalbail
8456e91bba0SGirish Moodalbail /*
8466e91bba0SGirish Moodalbail * Returns B_FALSE if
8476e91bba0SGirish Moodalbail * (1) `ifname' is NULL or has no string or has a string of invalid length
8486e91bba0SGirish Moodalbail * (2) ifname is a logical interface and IPH_LEGACY is not set, or
8496e91bba0SGirish Moodalbail */
8506e91bba0SGirish Moodalbail boolean_t
i_ipadm_validate_ifname(ipadm_handle_t iph,const char * ifname)8516e91bba0SGirish Moodalbail i_ipadm_validate_ifname(ipadm_handle_t iph, const char *ifname)
8526e91bba0SGirish Moodalbail {
8536e91bba0SGirish Moodalbail ifspec_t ifsp;
8546e91bba0SGirish Moodalbail
8556e91bba0SGirish Moodalbail if (ifname == NULL || ifname[0] == '\0' ||
8566e91bba0SGirish Moodalbail !ifparse_ifspec(ifname, &ifsp))
8576e91bba0SGirish Moodalbail return (B_FALSE);
8586e91bba0SGirish Moodalbail if (ifsp.ifsp_lunvalid)
8596e91bba0SGirish Moodalbail return (ifsp.ifsp_lun > 0 && (iph->iph_flags & IPH_LEGACY));
8606e91bba0SGirish Moodalbail return (B_TRUE);
8616e91bba0SGirish Moodalbail }
8626e91bba0SGirish Moodalbail
8636e91bba0SGirish Moodalbail /*
8646e91bba0SGirish Moodalbail * Wrapper for sending a non-transparent I_STR ioctl().
8656e91bba0SGirish Moodalbail * Returns: Result from ioctl().
8666e91bba0SGirish Moodalbail */
8676e91bba0SGirish Moodalbail int
i_ipadm_strioctl(int s,int cmd,char * buf,int buflen)8686e91bba0SGirish Moodalbail i_ipadm_strioctl(int s, int cmd, char *buf, int buflen)
8696e91bba0SGirish Moodalbail {
8706e91bba0SGirish Moodalbail struct strioctl ioc;
8716e91bba0SGirish Moodalbail
8726e91bba0SGirish Moodalbail (void) memset(&ioc, 0, sizeof (ioc));
8736e91bba0SGirish Moodalbail ioc.ic_cmd = cmd;
8746e91bba0SGirish Moodalbail ioc.ic_timout = 0;
8756e91bba0SGirish Moodalbail ioc.ic_len = buflen;
8766e91bba0SGirish Moodalbail ioc.ic_dp = buf;
8776e91bba0SGirish Moodalbail
8786e91bba0SGirish Moodalbail return (ioctl(s, I_STR, (char *)&ioc));
8796e91bba0SGirish Moodalbail }
8806e91bba0SGirish Moodalbail
8816e91bba0SGirish Moodalbail /*
8826e91bba0SGirish Moodalbail * Make a door call to the server and checks if the door call succeeded or not.
8836e91bba0SGirish Moodalbail * `is_varsize' specifies that the data returned by ipmgmtd daemon is of
8846e91bba0SGirish Moodalbail * variable size and door will allocate buffer using mmap(). In such cases
8856e91bba0SGirish Moodalbail * we re-allocate the required memory,n assign it to `rbufp', copy the data to
8866e91bba0SGirish Moodalbail * `rbufp' and then call munmap() (see below).
8876e91bba0SGirish Moodalbail *
8886e91bba0SGirish Moodalbail * It also checks to see if the server side procedure ran successfully by
8896e91bba0SGirish Moodalbail * checking for ir_err. Therefore, for some callers who just care about the
8906e91bba0SGirish Moodalbail * return status can set `rbufp' to NULL and set `rsize' to 0.
8916e91bba0SGirish Moodalbail */
8926e91bba0SGirish Moodalbail int
ipadm_door_call(ipadm_handle_t iph,void * arg,size_t asize,void ** rbufp,size_t rsize,boolean_t is_varsize)8936e91bba0SGirish Moodalbail ipadm_door_call(ipadm_handle_t iph, void *arg, size_t asize, void **rbufp,
8946e91bba0SGirish Moodalbail size_t rsize, boolean_t is_varsize)
8956e91bba0SGirish Moodalbail {
8966e91bba0SGirish Moodalbail door_arg_t darg;
8976e91bba0SGirish Moodalbail int err;
8986e91bba0SGirish Moodalbail ipmgmt_retval_t rval, *rvalp;
899f6da83d4SAnurag S. Maskey boolean_t reopen = B_FALSE;
9006e91bba0SGirish Moodalbail
9016e91bba0SGirish Moodalbail if (rbufp == NULL) {
9026e91bba0SGirish Moodalbail rvalp = &rval;
9036e91bba0SGirish Moodalbail rbufp = (void **)&rvalp;
9046e91bba0SGirish Moodalbail rsize = sizeof (rval);
9056e91bba0SGirish Moodalbail }
9066e91bba0SGirish Moodalbail
9076e91bba0SGirish Moodalbail darg.data_ptr = arg;
9086e91bba0SGirish Moodalbail darg.data_size = asize;
9096e91bba0SGirish Moodalbail darg.desc_ptr = NULL;
9106e91bba0SGirish Moodalbail darg.desc_num = 0;
9116e91bba0SGirish Moodalbail darg.rbuf = *rbufp;
9126e91bba0SGirish Moodalbail darg.rsize = rsize;
9136e91bba0SGirish Moodalbail
914f6da83d4SAnurag S. Maskey reopen:
9156e91bba0SGirish Moodalbail (void) pthread_mutex_lock(&iph->iph_lock);
9166e91bba0SGirish Moodalbail /* The door descriptor is opened if it isn't already */
9176e91bba0SGirish Moodalbail if (iph->iph_door_fd == -1) {
9186e91bba0SGirish Moodalbail if ((iph->iph_door_fd = open(IPMGMT_DOOR, O_RDONLY)) < 0) {
9196e91bba0SGirish Moodalbail err = errno;
9206e91bba0SGirish Moodalbail (void) pthread_mutex_unlock(&iph->iph_lock);
9216e91bba0SGirish Moodalbail return (err);
9226e91bba0SGirish Moodalbail }
9236e91bba0SGirish Moodalbail }
9246e91bba0SGirish Moodalbail (void) pthread_mutex_unlock(&iph->iph_lock);
9256e91bba0SGirish Moodalbail
926f6da83d4SAnurag S. Maskey if (door_call(iph->iph_door_fd, &darg) == -1) {
927f6da83d4SAnurag S. Maskey /*
928f6da83d4SAnurag S. Maskey * Stale door descriptor is possible if ipmgmtd was restarted
929f6da83d4SAnurag S. Maskey * since last iph_door_fd was opened, so try re-opening door
930f6da83d4SAnurag S. Maskey * descriptor.
931f6da83d4SAnurag S. Maskey */
932f6da83d4SAnurag S. Maskey if (!reopen && errno == EBADF) {
933f6da83d4SAnurag S. Maskey (void) close(iph->iph_door_fd);
934f6da83d4SAnurag S. Maskey iph->iph_door_fd = -1;
935f6da83d4SAnurag S. Maskey reopen = B_TRUE;
936f6da83d4SAnurag S. Maskey goto reopen;
937f6da83d4SAnurag S. Maskey }
9386e91bba0SGirish Moodalbail return (errno);
939f6da83d4SAnurag S. Maskey }
9406e91bba0SGirish Moodalbail err = ((ipmgmt_retval_t *)(void *)(darg.rbuf))->ir_err;
9416e91bba0SGirish Moodalbail if (darg.rbuf != *rbufp) {
9426e91bba0SGirish Moodalbail /*
9436e91bba0SGirish Moodalbail * if the caller is expecting the result to fit in specified
9446e91bba0SGirish Moodalbail * buffer then return failure.
9456e91bba0SGirish Moodalbail */
9466e91bba0SGirish Moodalbail if (!is_varsize)
9476e91bba0SGirish Moodalbail err = EBADE;
9486e91bba0SGirish Moodalbail /*
9496e91bba0SGirish Moodalbail * The size of the buffer `*rbufp' was not big enough
9506e91bba0SGirish Moodalbail * and the door itself allocated buffer, for us. We will
9516e91bba0SGirish Moodalbail * hit this, on several occasion as for some cases
9526e91bba0SGirish Moodalbail * we cannot predict the size of the return structure.
9536e91bba0SGirish Moodalbail * Reallocate the buffer `*rbufp' and memcpy() the contents
9546e91bba0SGirish Moodalbail * to new buffer.
9556e91bba0SGirish Moodalbail */
9566e91bba0SGirish Moodalbail if (err == 0) {
9576e91bba0SGirish Moodalbail void *newp;
9586e91bba0SGirish Moodalbail
9596e91bba0SGirish Moodalbail /* allocated memory will be freed by the caller */
9606e91bba0SGirish Moodalbail if ((newp = realloc(*rbufp, darg.rsize)) == NULL) {
9616e91bba0SGirish Moodalbail err = ENOMEM;
9626e91bba0SGirish Moodalbail } else {
9636e91bba0SGirish Moodalbail *rbufp = newp;
9646e91bba0SGirish Moodalbail (void) memcpy(*rbufp, darg.rbuf, darg.rsize);
9656e91bba0SGirish Moodalbail }
9666e91bba0SGirish Moodalbail }
9676e91bba0SGirish Moodalbail /* munmap() the door buffer */
9686e91bba0SGirish Moodalbail (void) munmap(darg.rbuf, darg.rsize);
9696e91bba0SGirish Moodalbail } else {
9706e91bba0SGirish Moodalbail if (darg.rsize != rsize)
9716e91bba0SGirish Moodalbail err = EBADE;
9726e91bba0SGirish Moodalbail }
9736e91bba0SGirish Moodalbail return (err);
9746e91bba0SGirish Moodalbail }
975b31320a7SChris Fraire
976a73be61aSHans Rosenfeld /*
977a73be61aSHans Rosenfeld * A helper that is used by i_ipadm_get_db_addr and i_ipadm_get_db_if
978a73be61aSHans Rosenfeld * to do a door_call to ipmgmtd, that should return persistent information
979a73be61aSHans Rosenfeld * about interfaces or/and addresses from ipadm DB
980a73be61aSHans Rosenfeld */
981a73be61aSHans Rosenfeld ipadm_status_t
i_ipadm_call_ipmgmtd(ipadm_handle_t iph,void * garg,size_t garg_size,nvlist_t ** onvl)982a73be61aSHans Rosenfeld i_ipadm_call_ipmgmtd(ipadm_handle_t iph, void *garg, size_t garg_size,
983a73be61aSHans Rosenfeld nvlist_t **onvl)
984a73be61aSHans Rosenfeld {
985a73be61aSHans Rosenfeld ipmgmt_get_rval_t *rvalp;
986a73be61aSHans Rosenfeld int err;
987a73be61aSHans Rosenfeld size_t nvlsize;
988a73be61aSHans Rosenfeld char *nvlbuf;
989a73be61aSHans Rosenfeld
990a73be61aSHans Rosenfeld rvalp = malloc(sizeof (ipmgmt_get_rval_t));
991a73be61aSHans Rosenfeld if (rvalp == NULL)
992a73be61aSHans Rosenfeld return (IPADM_NO_MEMORY);
993a73be61aSHans Rosenfeld
994a73be61aSHans Rosenfeld err = ipadm_door_call(iph, garg, garg_size, (void **)&rvalp,
995a73be61aSHans Rosenfeld sizeof (*rvalp), B_TRUE);
996a73be61aSHans Rosenfeld if (err == 0) {
997a73be61aSHans Rosenfeld nvlsize = rvalp->ir_nvlsize;
998a73be61aSHans Rosenfeld nvlbuf = (char *)rvalp + sizeof (ipmgmt_get_rval_t);
999a73be61aSHans Rosenfeld err = nvlist_unpack(nvlbuf, nvlsize, onvl, 0);
1000a73be61aSHans Rosenfeld }
1001a73be61aSHans Rosenfeld free(rvalp);
1002a73be61aSHans Rosenfeld
1003a73be61aSHans Rosenfeld return (ipadm_errno2status(err));
1004a73be61aSHans Rosenfeld }
1005a73be61aSHans Rosenfeld
1006b31320a7SChris Fraire /*
1007b31320a7SChris Fraire * ipadm_is_nil_hostname() : Determine if the `hostname' is nil: i.e.,
1008b31320a7SChris Fraire * NULL, empty, or a single space (e.g., as returned by
1009*bbf21555SRichard Lowe * domainname(8)/sysinfo).
1010b31320a7SChris Fraire *
1011b31320a7SChris Fraire * input: const char *: the hostname to inspect;
1012b31320a7SChris Fraire * output: boolean_t: B_TRUE if `hostname' is not NULL satisfies the
1013b31320a7SChris Fraire * criteria above; otherwise, B_FALSE;
1014b31320a7SChris Fraire */
1015b31320a7SChris Fraire
1016b31320a7SChris Fraire boolean_t
ipadm_is_nil_hostname(const char * hostname)1017b31320a7SChris Fraire ipadm_is_nil_hostname(const char *hostname)
1018b31320a7SChris Fraire {
1019b31320a7SChris Fraire return (hostname == NULL || *hostname == '\0' ||
1020b31320a7SChris Fraire (*hostname == ' ' && hostname[1] == '\0'));
1021b31320a7SChris Fraire }
1022b31320a7SChris Fraire
1023b31320a7SChris Fraire /*
1024b31320a7SChris Fraire * ipadm_is_valid_hostname(): check whether a string is a valid hostname
1025b31320a7SChris Fraire *
1026b31320a7SChris Fraire * input: const char *: the string to verify as a hostname
1027b31320a7SChris Fraire * output: boolean_t: B_TRUE if the string is a valid hostname
1028b31320a7SChris Fraire *
1029b31320a7SChris Fraire * Note that we accept host names beginning with a digit, which is not
1030b31320a7SChris Fraire * strictly legal according to the RFCs but is in common practice, so we
1031b31320a7SChris Fraire * endeavour to not break what customers are using.
1032b31320a7SChris Fraire *
1033b31320a7SChris Fraire * RFC 1035 limits a wire-format domain name to 255 octets. For a printable
1034b31320a7SChris Fraire * `hostname' as we have, the limit is therefore 253 characters (excluding
1035b31320a7SChris Fraire * the terminating '\0'--or 254 characters if the last character of
1036b31320a7SChris Fraire * `hostname' is a '.'.
1037b31320a7SChris Fraire *
1038b31320a7SChris Fraire * Excerpt from section 2.3.1., Preferred name syntax:
1039b31320a7SChris Fraire *
1040b31320a7SChris Fraire * <domain> ::= <subdomain> | " "
1041b31320a7SChris Fraire * <subdomain> ::= <label> | <subdomain> "." <label>
1042b31320a7SChris Fraire * <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
1043b31320a7SChris Fraire * <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
1044b31320a7SChris Fraire * <let-dig-hyp> ::= <let-dig> | "-"
1045b31320a7SChris Fraire * <let-dig> ::= <letter> | <digit>
1046b31320a7SChris Fraire */
1047b31320a7SChris Fraire boolean_t
ipadm_is_valid_hostname(const char * hostname)1048b31320a7SChris Fraire ipadm_is_valid_hostname(const char *hostname)
1049b31320a7SChris Fraire {
1050b31320a7SChris Fraire const size_t MAX_READABLE_NAME_LEN = 253;
1051b31320a7SChris Fraire char last_char;
1052b31320a7SChris Fraire size_t has_last_dot, namelen, i;
1053b31320a7SChris Fraire
1054b31320a7SChris Fraire if (hostname == NULL)
1055b31320a7SChris Fraire return (B_FALSE);
1056b31320a7SChris Fraire
1057b31320a7SChris Fraire namelen = strlen(hostname);
1058b31320a7SChris Fraire if (namelen < 1)
1059b31320a7SChris Fraire return (B_FALSE);
1060b31320a7SChris Fraire
1061b31320a7SChris Fraire last_char = hostname[namelen - 1];
1062b31320a7SChris Fraire has_last_dot = last_char == '.';
1063b31320a7SChris Fraire
1064b31320a7SChris Fraire if (namelen > MAX_READABLE_NAME_LEN + has_last_dot ||
1065b31320a7SChris Fraire last_char == '-')
1066b31320a7SChris Fraire return (B_FALSE);
1067b31320a7SChris Fraire
1068b31320a7SChris Fraire for (i = 0; hostname[i] != '\0'; i++) {
1069b31320a7SChris Fraire /*
1070b31320a7SChris Fraire * As noted above, this deviates from RFC 1035 in that it
1071b31320a7SChris Fraire * allows a leading digit.
1072b31320a7SChris Fraire */
1073b31320a7SChris Fraire if (isalpha(hostname[i]) || isdigit(hostname[i]) ||
1074b31320a7SChris Fraire (((hostname[i] == '-') || (hostname[i] == '.')) && (i > 0)))
1075b31320a7SChris Fraire continue;
1076b31320a7SChris Fraire
1077b31320a7SChris Fraire return (B_FALSE);
1078b31320a7SChris Fraire }
1079b31320a7SChris Fraire
1080b31320a7SChris Fraire return (B_TRUE);
1081b31320a7SChris Fraire }
1082