/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2021 Tintri by DDN, Inc. All rights reserved. */ /* * This RCM module adds support to the RCM framework for IP managed * interfaces. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "rcm_module.h" /* * Definitions */ #ifndef lint #define _(x) gettext(x) #else #define _(x) x #endif /* Some generic well-knowns and defaults used in this module */ #define ARP_MOD_NAME "arp" /* arp module */ #define IP_MAX_MODS 9 /* max modules pushed on intr */ #define MAX_RECONFIG_SIZE 1024 /* Max. reconfig string size */ #define RCM_LINK_PREFIX "SUNW_datalink" /* RCM datalink name prefix */ #define RCM_LINK_RESOURCE_MAX (13 + LINKID_STR_WIDTH) #define RCM_STR_SUNW_IP "SUNW_ip/" /* IP address export prefix */ #define SBIN_IFCONFIG "/sbin/ifconfig" /* ifconfig command */ #define SBIN_IFPARSE "/sbin/ifparse" /* ifparse command */ #define DHCPFILE_FMT "/etc/dhcp.%s" /* DHCP config file */ #define CFGFILE_FMT_IPV4 "/etc/hostname.%s" /* IPV4 config file */ #define CFGFILE_FMT_IPV6 "/etc/hostname6.%s" /* IPV6 config file */ #define CFG_CMDS_STD " netmask + broadcast + up" /* Normal config string */ #define CFG_DHCP_CMD "dhcp wait 0" /* command to start DHCP */ /* Some useful macros */ #define ISSPACE(c) ((c) == ' ' || (c) == '\t') #define ISEOL(c) ((c) == '\n' || (c) == '\r' || (c) == '\0') #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0) /* Interface Cache state flags */ #define CACHE_IF_STALE 0x1 /* stale cached data */ #define CACHE_IF_NEW 0x2 /* new cached interface */ #define CACHE_IF_OFFLINED 0x4 /* interface offlined */ #define CACHE_IF_IGNORE 0x8 /* state held elsewhere */ /* Network Cache lookup options */ #define CACHE_NO_REFRESH 0x1 /* cache refresh not needed */ #define CACHE_REFRESH 0x2 /* refresh cache */ /* RCM IPMP Module specific property definitions */ #define RCM_IPMP_MIN_REDUNDANCY 1 /* default min. redundancy */ /* Stream module operations */ #define MOD_INSERT 0 /* Insert a mid-stream module */ #define MOD_REMOVE 1 /* Remove a mid-stream module */ #define MOD_CHECK 2 /* Check mid-stream module safety */ /* * IP module data types */ /* Physical interface representation */ typedef struct ip_pif { char pi_ifname[LIFNAMSIZ]; /* interface name */ char pi_grname[LIFGRNAMSIZ]; /* IPMP group name */ struct ip_lif *pi_lifs; /* ptr to logical interfaces */ } ip_pif_t; /* Logical interface representation */ typedef struct ip_lif { struct ip_lif *li_next; /* ptr to next lif */ struct ip_lif *li_prev; /* previous next ptr */ ip_pif_t *li_pif; /* back ptr to phy int */ ushort_t li_ifnum; /* interface number */ union { sa_family_t family; struct sockaddr_storage storage; struct sockaddr_in ip4; /* IPv4 */ struct sockaddr_in6 ip6; /* IPv6 */ } li_addr; uint64_t li_ifflags; /* current IFF_* flags */ int li_modcnt; /* # of modules */ char *li_modules[IP_MAX_MODS]; /* module list pushed */ char *li_reconfig; /* Reconfiguration string */ int32_t li_cachestate; /* cache state flags */ } ip_lif_t; /* Cache element */ typedef struct ip_cache { struct ip_cache *ip_next; /* next cached resource */ struct ip_cache *ip_prev; /* prev cached resource */ char *ip_resource; /* resource name */ ip_pif_t *ip_pif; /* ptr to phy int */ int32_t ip_ifred; /* min. redundancy */ int ip_cachestate; /* cache state flags */ } ip_cache_t; /* * Global cache for network interfaces */ static ip_cache_t cache_head; static ip_cache_t cache_tail; static mutex_t cache_lock; static int events_registered = 0; static dladm_handle_t dld_handle = NULL; static ipadm_handle_t ip_handle = NULL; /* * RCM module interface prototypes */ static int ip_register(rcm_handle_t *); static int ip_unregister(rcm_handle_t *); static int ip_get_info(rcm_handle_t *, char *, id_t, uint_t, char **, char **, nvlist_t *, rcm_info_t **); static int ip_suspend(rcm_handle_t *, char *, id_t, timespec_t *, uint_t, char **, rcm_info_t **); static int ip_resume(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int ip_offline(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int ip_undo_offline(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int ip_remove(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int ip_notify_event(rcm_handle_t *, char *, id_t, uint_t, char **, nvlist_t *, rcm_info_t **); /* Module private routines */ static void free_cache(); static int update_cache(rcm_handle_t *); static void cache_remove(ip_cache_t *); static ip_cache_t *cache_lookup(rcm_handle_t *, char *, char); static void free_node(ip_cache_t *); static void cache_insert(ip_cache_t *); static char *ip_usage(ip_cache_t *); static int update_pif(rcm_handle_t *, int, int, struct ifaddrs *); static int ip_ipmp_offline(ip_cache_t *); static int ip_ipmp_undo_offline(ip_cache_t *); static int if_cfginfo(ip_cache_t *, uint_t); static int if_unplumb(ip_cache_t *); static int if_replumb(ip_cache_t *); static void ip_log_err(ip_cache_t *, char **, char *); static char *get_link_resource(const char *); static void clr_cfg_state(ip_pif_t *); static int modop(char *, char *, int, char); static int get_modlist(char *, ip_lif_t *); static int ip_domux2fd(int *, int *, int *, struct lifreq *); static int ip_plink(int, int, int, struct lifreq *); static int ip_onlinelist(rcm_handle_t *, ip_cache_t *, char **, uint_t, rcm_info_t **); static int ip_offlinelist(rcm_handle_t *, ip_cache_t *, char **, uint_t, rcm_info_t **); static char **ip_get_addrlist(ip_cache_t *); static void ip_free_addrlist(char **); static void ip_consumer_notify(rcm_handle_t *, datalink_id_t, char **, uint_t, rcm_info_t **); static boolean_t ip_addrstr(ip_lif_t *, char *, size_t); static int if_configure_hostname(datalink_id_t); static int if_configure_ipadm(datalink_id_t); static boolean_t if_hostname_exists(char *, sa_family_t); static boolean_t isgrouped(const char *); static int if_config_inst(const char *, FILE *, int, boolean_t); static uint_t ntok(const char *cp); static boolean_t ifconfig(const char *, const char *, const char *, boolean_t); /* Module-Private data */ static struct rcm_mod_ops ip_ops = { RCM_MOD_OPS_VERSION, ip_register, ip_unregister, ip_get_info, ip_suspend, ip_resume, ip_offline, ip_undo_offline, ip_remove, NULL, NULL, ip_notify_event }; /* * rcm_mod_init() - Update registrations, and return the ops structure. */ struct rcm_mod_ops * rcm_mod_init(void) { char errmsg[DLADM_STRSIZE]; dladm_status_t status; ipadm_status_t iph_status; rcm_log_message(RCM_TRACE1, "IP: mod_init\n"); cache_head.ip_next = &cache_tail; cache_head.ip_prev = NULL; cache_tail.ip_prev = &cache_head; cache_tail.ip_next = NULL; (void) mutex_init(&cache_lock, USYNC_THREAD, NULL); if ((status = dladm_open(&dld_handle)) != DLADM_STATUS_OK) { rcm_log_message(RCM_WARNING, "IP: mod_init failed: cannot get datalink handle: %s\n", dladm_status2str(status, errmsg)); return (NULL); } if ((iph_status = ipadm_open(&ip_handle, 0)) != IPADM_SUCCESS) { rcm_log_message(RCM_ERROR, "IP: mod_init failed: cannot get IP handle: %s\n", ipadm_status2str(iph_status)); dladm_close(dld_handle); dld_handle = NULL; return (NULL); } /* Return the ops vectors */ return (&ip_ops); } /* * rcm_mod_info() - Return a string describing this module. */ const char * rcm_mod_info(void) { rcm_log_message(RCM_TRACE1, "IP: mod_info\n"); return ("IP Multipathing module version 1.23"); } /* * rcm_mod_fini() - Destroy the network interfaces cache. */ int rcm_mod_fini(void) { rcm_log_message(RCM_TRACE1, "IP: mod_fini\n"); free_cache(); (void) mutex_destroy(&cache_lock); dladm_close(dld_handle); ipadm_close(ip_handle); return (RCM_SUCCESS); } /* * ip_register() - Make sure the cache is properly sync'ed, and its * registrations are in order. */ static int ip_register(rcm_handle_t *hd) { rcm_log_message(RCM_TRACE1, "IP: register\n"); /* Guard against bad arguments */ assert(hd != NULL); if (update_cache(hd) < 0) return (RCM_FAILURE); /* * Need to register interest in all new resources * getting attached, so we get attach event notifications */ if (!events_registered) { if (rcm_register_event(hd, RCM_RESOURCE_LINK_NEW, 0, NULL) != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: failed to register %s\n"), RCM_RESOURCE_LINK_NEW); return (RCM_FAILURE); } else { rcm_log_message(RCM_DEBUG, "IP: registered %s\n", RCM_RESOURCE_LINK_NEW); events_registered++; } } return (RCM_SUCCESS); } /* * ip_unregister() - Walk the cache, unregistering all the networks. */ static int ip_unregister(rcm_handle_t *hd) { ip_cache_t *probe; rcm_log_message(RCM_TRACE1, "IP: unregister\n"); /* Guard against bad arguments */ assert(hd != NULL); /* Walk the cache, unregistering everything */ (void) mutex_lock(&cache_lock); probe = cache_head.ip_next; while (probe != &cache_tail) { if (rcm_unregister_interest(hd, probe->ip_resource, 0) != RCM_SUCCESS) { /* unregister failed for whatever reason */ (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } cache_remove(probe); free_node(probe); probe = cache_head.ip_next; } (void) mutex_unlock(&cache_lock); /* * Need to unregister interest in all new resources */ if (events_registered) { if (rcm_unregister_event(hd, RCM_RESOURCE_LINK_NEW, 0) != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: failed to unregister %s\n"), RCM_RESOURCE_LINK_NEW); return (RCM_FAILURE); } else { rcm_log_message(RCM_DEBUG, "IP: unregistered %s\n", RCM_RESOURCE_LINK_NEW); events_registered--; } } return (RCM_SUCCESS); } /* * ip_offline() - Offline an interface. */ static int ip_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, rcm_info_t **depend_info) { ip_cache_t *node; ip_pif_t *pif; boolean_t detachable = B_FALSE; boolean_t ipmp; int retval; rcm_log_message(RCM_TRACE1, "IP: offline(%s)\n", rsrc); /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); assert(depend_info != NULL); /* Lock the cache and lookup the resource */ (void) mutex_lock(&cache_lock); node = cache_lookup(hd, rsrc, CACHE_REFRESH); if (node == NULL) { ip_log_err(node, errorp, "Unrecognized resource"); errno = ENOENT; (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } pif = node->ip_pif; /* Establish default detachability criteria */ if (flags & RCM_FORCE) detachable = B_TRUE; /* Check if the interface is under IPMP */ ipmp = (pif->pi_grname[0] != '\0'); /* * Even if the interface is not under IPMP, it's possible that it's * still okay to offline it as long as there are higher-level failover * mechanisms for the addresses it owns (e.g., clustering). In this * case, ip_offlinelist() will return RCM_SUCCESS, and we charge on. */ if (!ipmp && !detachable) { /* Inform consumers of IP addresses being offlined */ if (ip_offlinelist(hd, node, errorp, flags, depend_info) == RCM_SUCCESS) { rcm_log_message(RCM_DEBUG, "IP: consumers agree on detach"); } else { ip_log_err(node, errorp, "Device consumers prohibit offline"); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } } /* Check if it's a query */ if (flags & RCM_QUERY) { rcm_log_message(RCM_TRACE1, "IP: offline query success(%s)\n", rsrc); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* Check detachability, save configuration if detachable */ if (if_cfginfo(node, (flags & RCM_FORCE)) < 0) { node->ip_cachestate |= CACHE_IF_IGNORE; rcm_log_message(RCM_TRACE1, "IP: Ignoring node(%s)\n", rsrc); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* standalone detachable device */ if (!ipmp) { if (if_unplumb(node) < 0) { ip_log_err(node, errorp, "Failed to unplumb the device"); errno = EIO; (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } node->ip_cachestate |= CACHE_IF_OFFLINED; rcm_log_message(RCM_TRACE1, "IP: Offline success(%s)\n", rsrc); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * This is an IPMP interface that can be offlined. * Request in.mpathd(8) to offline the physical interface. */ if ((retval = ip_ipmp_offline(node)) != IPMP_SUCCESS) ip_log_err(node, errorp, "in.mpathd offline failed"); if (retval == IPMP_EMINRED && !detachable) { /* * in.mpathd(8) could not offline the device because it was * the last interface in the group. However, it's possible * that it's still okay to offline it as long as there are * higher-level failover mechanisms for the addresses it owns * (e.g., clustering). In this case, ip_offlinelist() will * return RCM_SUCCESS, and we charge on. */ /* Inform consumers of IP addresses being offlined */ if (ip_offlinelist(hd, node, errorp, flags, depend_info) == RCM_SUCCESS) { rcm_log_message(RCM_DEBUG, "IP: consumers agree on detach"); } else { ip_log_err(node, errorp, "Device consumers prohibit offline"); (void) mutex_unlock(&cache_lock); errno = EBUSY; return (RCM_FAILURE); } } if (if_unplumb(node) < 0) { rcm_log_message(RCM_ERROR, _("IP: Unplumb failed (%s)\n"), pif->pi_ifname); /* Request in.mpathd to undo the offline */ if (ip_ipmp_undo_offline(node) != IPMP_SUCCESS) { ip_log_err(node, errorp, "Undo offline failed"); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } node->ip_cachestate |= CACHE_IF_OFFLINED; rcm_log_message(RCM_TRACE1, "IP: offline success(%s)\n", rsrc); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * ip_undo_offline() - Undo offline of a previously offlined device. */ /*ARGSUSED*/ static int ip_undo_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, rcm_info_t **depend_info) { ip_cache_t *node; rcm_log_message(RCM_TRACE1, "IP: online(%s)\n", rsrc); /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); assert(depend_info != NULL); (void) mutex_lock(&cache_lock); node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); if (node == NULL) { ip_log_err(node, errorp, "No such device"); (void) mutex_unlock(&cache_lock); errno = ENOENT; return (RCM_FAILURE); } /* Check if no attempt should be made to online the device here */ if (node->ip_cachestate & CACHE_IF_IGNORE) { node->ip_cachestate &= ~(CACHE_IF_IGNORE); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* Check if the interface was previously offlined */ if (!(node->ip_cachestate & CACHE_IF_OFFLINED)) { ip_log_err(node, errorp, "Device not offlined"); (void) mutex_unlock(&cache_lock); errno = ENOTSUP; return (RCM_FAILURE); } if (if_replumb(node) == -1) { /* re-plumb failed */ ip_log_err(node, errorp, "Replumb failed"); (void) mutex_unlock(&cache_lock); errno = EIO; return (RCM_FAILURE); } /* Inform consumers about IP addresses being un-offlined */ (void) ip_onlinelist(hd, node, errorp, flags, depend_info); node->ip_cachestate &= ~(CACHE_IF_OFFLINED); rcm_log_message(RCM_TRACE1, "IP: online success(%s)\n", rsrc); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * ip_get_info() - Gather usage information for this resource. */ /*ARGSUSED*/ int ip_get_info(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **usagep, char **errorp, nvlist_t *props, rcm_info_t **depend_info) { ip_cache_t *node; char *infostr; /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(usagep != NULL); assert(errorp != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, "IP: get_info(%s)\n", rsrc); (void) mutex_lock(&cache_lock); node = cache_lookup(hd, rsrc, CACHE_REFRESH); if (!node) { rcm_log_message(RCM_INFO, _("IP: get_info(%s) unrecognized resource\n"), rsrc); (void) mutex_unlock(&cache_lock); errno = ENOENT; return (RCM_FAILURE); } infostr = ip_usage(node); if (infostr == NULL) { /* most likely malloc failure */ rcm_log_message(RCM_ERROR, _("IP: get_info(%s) malloc failure\n"), rsrc); (void) mutex_unlock(&cache_lock); errno = ENOMEM; *errorp = NULL; return (RCM_FAILURE); } /* Set client/role properties */ (void) nvlist_add_string(props, RCM_CLIENT_NAME, "IP"); /* Set usage property, infostr will be freed by caller */ *usagep = infostr; rcm_log_message(RCM_TRACE1, "IP: get_info(%s) info = %s \n", rsrc, infostr); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * ip_suspend() - Nothing to do, always okay */ /*ARGSUSED*/ static int ip_suspend(rcm_handle_t *hd, char *rsrc, id_t id, timespec_t *interval, uint_t flags, char **errorp, rcm_info_t **depend_info) { /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(interval != NULL); assert(errorp != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, "IP: suspend(%s)\n", rsrc); return (RCM_SUCCESS); } /* * ip_resume() - Nothing to do, always okay */ /*ARGSUSED*/ static int ip_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, rcm_info_t ** depend_info) { /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, "IP: resume(%s)\n", rsrc); return (RCM_SUCCESS); } /* * ip_remove() - remove a resource from cache */ /*ARGSUSED*/ static int ip_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, rcm_info_t **depend_info) { ip_cache_t *node; /* Guard against bad arguments */ assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, "IP: remove(%s)\n", rsrc); (void) mutex_lock(&cache_lock); node = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); if (!node) { rcm_log_message(RCM_INFO, _("IP: remove(%s) unrecognized resource\n"), rsrc); (void) mutex_unlock(&cache_lock); errno = ENOENT; return (RCM_FAILURE); } /* remove the cached entry for the resource */ cache_remove(node); free_node(node); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * ip_notify_event - Project private implementation to receive new resource * events. It intercepts all new resource events. If the * new resource is a network resource, pass up a notify * for it too. The new resource need not be cached, since * it is done at register again. */ /*ARGSUSED*/ static int ip_notify_event(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, nvlist_t *nvl, rcm_info_t **depend_info) { datalink_id_t linkid; nvpair_t *nvp = NULL; uint64_t id64; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(nvl != NULL); rcm_log_message(RCM_TRACE1, "IP: notify_event(%s)\n", rsrc); if (!STREQ(rsrc, RCM_RESOURCE_LINK_NEW)) { rcm_log_message(RCM_INFO, _("IP: unrecognized event for %s\n"), rsrc); ip_log_err(NULL, errorp, "unrecognized event"); errno = EINVAL; return (RCM_FAILURE); } /* Update cache to reflect latest interfaces */ if (update_cache(hd) < 0) { rcm_log_message(RCM_ERROR, _("IP: update_cache failed\n")); ip_log_err(NULL, errorp, "Private Cache update failed"); return (RCM_FAILURE); } rcm_log_message(RCM_TRACE1, "IP: process_nvlist\n"); while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { if (STREQ(nvpair_name(nvp), RCM_NV_LINKID)) { if (nvpair_value_uint64(nvp, &id64) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get linkid\n")); return (RCM_FAILURE); } linkid = (datalink_id_t)id64; /* * Grovel through /etc/hostname* files and configure * interface in the same way that they would be handled * by network/physical. */ if (if_configure_hostname(linkid) != 0) { rcm_log_message(RCM_ERROR, _("IP: Configuration failed (%u)\n"), linkid); ip_log_err(NULL, errorp, "Failed configuring one or more IP " "addresses"); } /* * Query libipadm for persistent configuration info * and resurrect that persistent configuration. */ if (if_configure_ipadm(linkid) != 0) { rcm_log_message(RCM_ERROR, _("IP: Configuration failed (%u)\n"), linkid); ip_log_err(NULL, errorp, "Failed configuring one or more IP " "addresses"); } /* Notify all IP address consumers */ ip_consumer_notify(hd, linkid, errorp, flags, depend_info); } } rcm_log_message(RCM_TRACE1, "IP: notify_event: device configuration complete\n"); return (RCM_SUCCESS); } /* * ip_usage - Determine the usage of a device. Call with cache_lock held. * The returned buffer is owned by caller, and the caller * must free it up when done. */ static char * ip_usage(ip_cache_t *node) { ip_lif_t *lif; uint_t numup; char *sep, *buf, *linkidstr; datalink_id_t linkid; const char *msg; char link[MAXLINKNAMELEN]; char addrstr[INET6_ADDRSTRLEN]; char errmsg[DLADM_STRSIZE]; dladm_status_t status; boolean_t offline, ipmp; size_t bufsz = 0; rcm_log_message(RCM_TRACE2, "IP: usage(%s)\n", node->ip_resource); /* * Note that node->ip_resource is in the form of SUNW_datalink/ */ linkidstr = strchr(node->ip_resource, '/'); assert(linkidstr != NULL); linkidstr = linkidstr ? linkidstr + 1 : node->ip_resource; errno = 0; linkid = strtol(linkidstr, &buf, 10); if (errno != 0 || *buf != '\0') { rcm_log_message(RCM_ERROR, _("IP: usage(%s) parse linkid failure (%s)\n"), node->ip_resource, strerror(errno)); return (NULL); } if ((status = dladm_datalink_id2info(dld_handle, linkid, NULL, NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { rcm_log_message(RCM_ERROR, _("IP: usage(%s) get link name failure(%s)\n"), node->ip_resource, dladm_status2str(status, errmsg)); return (NULL); } /* TRANSLATION_NOTE: separator used between IP addresses */ sep = _(", "); numup = 0; for (lif = node->ip_pif->pi_lifs; lif != NULL; lif = lif->li_next) if (lif->li_ifflags & IFF_UP) numup++; ipmp = (node->ip_pif->pi_grname[0] != '\0'); offline = ((node->ip_cachestate & CACHE_IF_OFFLINED) != 0); if (offline) { msg = _("offlined"); } else if (numup == 0) { msg = _("plumbed but down"); } else { if (ipmp) { msg = _("providing connectivity for IPMP group "); bufsz += LIFGRNAMSIZ; } else { msg = _("hosts IP addresses: "); bufsz += (numup * (INET6_ADDRSTRLEN + strlen(sep))); } } bufsz += strlen(link) + strlen(msg) + 1; if ((buf = malloc(bufsz)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: usage(%s) malloc failure(%s)\n"), node->ip_resource, strerror(errno)); return (NULL); } (void) snprintf(buf, bufsz, "%s: %s", link, msg); if (!offline && numup > 0) { if (ipmp) { (void) strlcat(buf, node->ip_pif->pi_grname, bufsz); } else { lif = node->ip_pif->pi_lifs; for (; lif != NULL; lif = lif->li_next) { if (!(lif->li_ifflags & IFF_UP)) continue; if (!ip_addrstr(lif, addrstr, sizeof (addrstr))) continue; (void) strlcat(buf, addrstr, bufsz); if (--numup > 0) (void) strlcat(buf, sep, bufsz); } } } rcm_log_message(RCM_TRACE2, "IP: usage (%s) info = %s\n", node->ip_resource, buf); return (buf); } static boolean_t ip_addrstr(ip_lif_t *lif, char *addrstr, size_t addrsize) { int af = lif->li_addr.family; void *addr; if (af == AF_INET6) { addr = &lif->li_addr.ip6.sin6_addr; } else if (af == AF_INET) { addr = &lif->li_addr.ip4.sin_addr; } else { rcm_log_message(RCM_DEBUG, "IP: unknown addr family %d, assuming AF_INET\n", af); af = AF_INET; addr = &lif->li_addr.ip4.sin_addr; } if (inet_ntop(af, addr, addrstr, addrsize) == NULL) { rcm_log_message(RCM_ERROR, _("IP: inet_ntop: %s\n"), strerror(errno)); return (B_FALSE); } rcm_log_message(RCM_DEBUG, "IP addr := %s\n", addrstr); return (B_TRUE); } /* * Cache management routines, all cache management functions should be * be called with cache_lock held. */ /* * cache_lookup() - Get a cache node for a resource. * Call with cache lock held. * * This ensures that the cache is consistent with the system state and * returns a pointer to the cache element corresponding to the resource. */ static ip_cache_t * cache_lookup(rcm_handle_t *hd, char *rsrc, char options) { ip_cache_t *probe; rcm_log_message(RCM_TRACE2, "IP: cache lookup(%s)\n", rsrc); if ((options & CACHE_REFRESH) && (hd != NULL)) { /* drop lock since update locks cache again */ (void) mutex_unlock(&cache_lock); (void) update_cache(hd); (void) mutex_lock(&cache_lock); } probe = cache_head.ip_next; while (probe != &cache_tail) { if (probe->ip_resource && STREQ(rsrc, probe->ip_resource)) { rcm_log_message(RCM_TRACE2, "IP: cache lookup success(%s)\n", rsrc); return (probe); } probe = probe->ip_next; } return (NULL); } /* * free_node - Free a node from the cache * Call with cache_lock held. */ static void free_node(ip_cache_t *node) { ip_pif_t *pif; ip_lif_t *lif, *tmplif; if (node) { if (node->ip_resource) { free(node->ip_resource); } /* free the pif */ pif = node->ip_pif; if (pif) { /* free logical interfaces */ lif = pif->pi_lifs; while (lif) { tmplif = lif->li_next; free(lif); lif = tmplif; } free(pif); } free(node); } } /* * cache_insert - Insert a resource node in cache * Call with the cache_lock held. */ static void cache_insert(ip_cache_t *node) { rcm_log_message(RCM_TRACE2, "IP: cache insert(%s)\n", node->ip_resource); /* insert at the head for best performance */ node->ip_next = cache_head.ip_next; node->ip_prev = &cache_head; node->ip_next->ip_prev = node; node->ip_prev->ip_next = node; } /* * cache_remove() - Remove a resource node from cache. * Call with the cache_lock held. */ static void cache_remove(ip_cache_t *node) { rcm_log_message(RCM_TRACE2, "IP: cache remove(%s)\n", node->ip_resource); node->ip_next->ip_prev = node->ip_prev; node->ip_prev->ip_next = node->ip_next; node->ip_next = NULL; node->ip_prev = NULL; } /* * update_pif() - Update physical interface properties * Call with cache_lock held */ int update_pif(rcm_handle_t *hd, int af, int sock, struct ifaddrs *ifa) { char *rsrc; ifspec_t ifspec; ushort_t ifnumber = 0; ip_cache_t *probe; ip_pif_t pif; ip_pif_t *probepif; ip_lif_t *probelif; struct lifreq lifreq; struct sockaddr_storage ifaddr; uint64_t ifflags; int lif_listed = 0; rcm_log_message(RCM_TRACE1, "IP: update_pif(%s)\n", ifa->ifa_name); if (!ifparse_ifspec(ifa->ifa_name, &ifspec)) { rcm_log_message(RCM_ERROR, _("IP: bad network interface: %s\n"), ifa->ifa_name); return (-1); } (void) snprintf(pif.pi_ifname, sizeof (pif.pi_ifname), "%s%d", ifspec.ifsp_devnm, ifspec.ifsp_ppa); if (ifspec.ifsp_lunvalid) ifnumber = ifspec.ifsp_lun; /* Get the interface flags */ ifflags = ifa->ifa_flags; /* * Ignore interfaces that are always incapable of DR: * - IFF_VIRTUAL: e.g., loopback and vni * - IFF_POINTOPOINT: e.g., sppp and ip.tun * - !IFF_MULTICAST: e.g., ip.6to4tun * - IFF_IPMP: IPMP meta-interfaces * * Note: The !IFF_MULTICAST check can be removed once iptun is * implemented as a datalink. */ if (!(ifflags & IFF_MULTICAST) || (ifflags & (IFF_POINTOPOINT | IFF_VIRTUAL | IFF_IPMP))) { rcm_log_message(RCM_TRACE3, "IP: if ignored (%s)\n", pif.pi_ifname); return (0); } /* Get the interface group name for this interface */ bzero(&lifreq, sizeof (lifreq)); (void) strncpy(lifreq.lifr_name, ifa->ifa_name, LIFNAMSIZ); if (ioctl(sock, SIOCGLIFGROUPNAME, (char *)&lifreq) < 0) { if (errno != ENXIO) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFGROUPNAME(%s): %s\n"), lifreq.lifr_name, strerror(errno)); } return (-1); } /* copy the group name */ (void) strlcpy(pif.pi_grname, lifreq.lifr_groupname, sizeof (pif.pi_grname)); /* Get the interface address for this interface */ (void) memcpy(&ifaddr, ifa->ifa_addr, sizeof (ifaddr)); rsrc = get_link_resource(pif.pi_ifname); if (rsrc == NULL) { rcm_log_message(RCM_ERROR, _("IP: get_link_resource(%s) failed\n"), lifreq.lifr_name); return (-1); } probe = cache_lookup(hd, rsrc, CACHE_NO_REFRESH); if (probe != NULL) { free(rsrc); probe->ip_cachestate &= ~(CACHE_IF_STALE); } else { if ((probe = calloc(1, sizeof (ip_cache_t))) == NULL) { /* malloc errors are bad */ free(rsrc); rcm_log_message(RCM_ERROR, _("IP: calloc: %s\n"), strerror(errno)); return (-1); } probe->ip_resource = rsrc; probe->ip_pif = NULL; probe->ip_ifred = RCM_IPMP_MIN_REDUNDANCY; probe->ip_cachestate |= CACHE_IF_NEW; cache_insert(probe); } probepif = probe->ip_pif; if (probepif != NULL) { /* Check if lifs need to be updated */ probelif = probepif->pi_lifs; while (probelif != NULL) { if ((probelif->li_ifnum == ifnumber) && (probelif->li_addr.family == ifaddr.ss_family)) { rcm_log_message(RCM_TRACE2, "IP: refreshing lifs for %s, ifnum=%d\n", pif.pi_ifname, probelif->li_ifnum); /* refresh lif properties */ (void) memcpy(&probelif->li_addr, &ifaddr, sizeof (probelif->li_addr)); probelif->li_ifflags = ifflags; lif_listed++; probelif->li_cachestate &= ~(CACHE_IF_STALE); break; } probelif = probelif->li_next; } } if (probepif == NULL) { if ((probepif = calloc(1, sizeof (ip_pif_t))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc: %s\n"), strerror(errno)); if (probe->ip_pif == NULL) { /* we created it, so clean it up */ free(probe); } return (-1); } probe->ip_pif = probepif; /* Save interface name */ (void) memcpy(&probepif->pi_ifname, &pif.pi_ifname, sizeof (pif.pi_ifname)); } /* save the group name */ (void) strlcpy(probepif->pi_grname, pif.pi_grname, sizeof (pif.pi_grname)); /* add lif, if this is a lif and it is not in cache */ if (!lif_listed) { rcm_log_message(RCM_TRACE2, "IP: adding lifs to %s\n", pif.pi_ifname); if ((probelif = calloc(1, sizeof (ip_lif_t))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc: %s\n"), strerror(errno)); return (-1); } /* save lif properties */ (void) memcpy(&probelif->li_addr, &ifaddr, sizeof (probelif->li_addr)); probelif->li_ifnum = ifnumber; probelif->li_ifflags = ifflags; /* insert us at the head of the lif list */ probelif->li_next = probepif->pi_lifs; if (probelif->li_next != NULL) { probelif->li_next->li_prev = probelif; } probelif->li_prev = NULL; probelif->li_pif = probepif; probepif->pi_lifs = probelif; } rcm_log_message(RCM_TRACE3, "IP: update_pif: (%s) success\n", probe->ip_resource); return (0); } /* * update_ipifs() - Determine all network interfaces in the system * Call with cache_lock held */ static int update_ipifs(rcm_handle_t *hd, int af) { struct ifaddrs *ifa; ipadm_addr_info_t *ainfo; ipadm_addr_info_t *ptr; ipadm_status_t status; int sock; if ((sock = socket(af, SOCK_DGRAM, 0)) == -1) { rcm_log_message(RCM_ERROR, _("IP: failure opening %s socket: %s\n"), af == AF_INET6 ? "IPv6" : "IPv4", strerror(errno)); return (-1); } status = ipadm_addr_info(ip_handle, NULL, &ainfo, IPADM_OPT_ZEROADDR, LIFC_UNDER_IPMP); if (status != IPADM_SUCCESS) { (void) close(sock); return (-1); } for (ptr = ainfo; ptr; ptr = IA_NEXT(ptr)) { ifa = &ptr->ia_ifa; if (ptr->ia_state != IFA_DISABLED && af == ifa->ifa_addr->sa_family) (void) update_pif(hd, af, sock, ifa); } (void) close(sock); ipadm_free_addr_info(ainfo); return (0); } /* * update_cache() - Update cache with latest interface info */ static int update_cache(rcm_handle_t *hd) { ip_cache_t *probe; struct ip_lif *lif; struct ip_lif *nextlif; int rv; int i; rcm_log_message(RCM_TRACE2, "IP: update_cache\n"); (void) mutex_lock(&cache_lock); /* first we walk the entire cache, marking each entry stale */ probe = cache_head.ip_next; while (probe != &cache_tail) { probe->ip_cachestate |= CACHE_IF_STALE; if ((probe->ip_pif != NULL) && ((lif = probe->ip_pif->pi_lifs) != NULL)) { while (lif != NULL) { lif->li_cachestate |= CACHE_IF_STALE; lif = lif->li_next; } } probe = probe->ip_next; } rcm_log_message(RCM_TRACE2, "IP: scanning IPv4 interfaces\n"); if (update_ipifs(hd, AF_INET) < 0) { (void) mutex_unlock(&cache_lock); return (-1); } rcm_log_message(RCM_TRACE2, "IP: scanning IPv6 interfaces\n"); if (update_ipifs(hd, AF_INET6) < 0) { (void) mutex_unlock(&cache_lock); return (-1); } probe = cache_head.ip_next; /* unregister devices that are not offlined and still in cache */ while (probe != &cache_tail) { ip_cache_t *freeit; if ((probe->ip_pif != NULL) && ((lif = probe->ip_pif->pi_lifs) != NULL)) { /* clear stale lifs */ while (lif != NULL) { if (lif->li_cachestate & CACHE_IF_STALE) { nextlif = lif->li_next; if (lif->li_prev != NULL) lif->li_prev->li_next = nextlif; if (nextlif != NULL) nextlif->li_prev = lif->li_prev; if (probe->ip_pif->pi_lifs == lif) probe->ip_pif->pi_lifs = nextlif; for (i = 0; i < IP_MAX_MODS; i++) { free(lif->li_modules[i]); } free(lif->li_reconfig); free(lif); lif = nextlif; } else { lif = lif->li_next; } } } if ((probe->ip_cachestate & CACHE_IF_STALE) && !(probe->ip_cachestate & CACHE_IF_OFFLINED)) { (void) rcm_unregister_interest(hd, probe->ip_resource, 0); rcm_log_message(RCM_DEBUG, "IP: unregistered %s\n", probe->ip_resource); freeit = probe; probe = probe->ip_next; cache_remove(freeit); free_node(freeit); continue; } if (!(probe->ip_cachestate & CACHE_IF_NEW)) { probe = probe->ip_next; continue; } rv = rcm_register_interest(hd, probe->ip_resource, 0, NULL); if (rv != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: failed to register %s\n"), probe->ip_resource); (void) mutex_unlock(&cache_lock); return (-1); } else { rcm_log_message(RCM_DEBUG, "IP: registered %s\n", probe->ip_resource); probe->ip_cachestate &= ~(CACHE_IF_NEW); } probe = probe->ip_next; } (void) mutex_unlock(&cache_lock); return (0); } /* * free_cache() - Empty the cache */ static void free_cache() { ip_cache_t *probe; rcm_log_message(RCM_TRACE2, "IP: free_cache\n"); (void) mutex_lock(&cache_lock); probe = cache_head.ip_next; while (probe != &cache_tail) { cache_remove(probe); free_node(probe); probe = cache_head.ip_next; } (void) mutex_unlock(&cache_lock); } /* * ip_log_err() - RCM error log wrapper */ static void ip_log_err(ip_cache_t *node, char **errorp, char *errmsg) { char *ifname = NULL; int size; const char *errfmt; char *error = NULL; if (node != NULL && node->ip_pif != NULL) { ifname = node->ip_pif->pi_ifname; } if (ifname == NULL) { rcm_log_message(RCM_ERROR, _("IP: %s\n"), errmsg); errfmt = _("IP: %s"); size = strlen(errfmt) + strlen(errmsg) + 1; if (errorp != NULL && (error = malloc(size)) != NULL) (void) snprintf(error, size, errfmt, errmsg); } else { rcm_log_message(RCM_ERROR, _("IP: %s(%s)\n"), errmsg, ifname); errfmt = _("IP: %s(%s)"); size = strlen(errfmt) + strlen(errmsg) + strlen(ifname) + 1; if (errorp != NULL && (error = malloc(size)) != NULL) (void) snprintf(error, size, errfmt, errmsg, ifname); } if (errorp != NULL) *errorp = error; } /* * if_cfginfo() - Save off the config info for all interfaces */ static int if_cfginfo(ip_cache_t *node, uint_t force) { ip_lif_t *lif; ip_pif_t *pif; int i; FILE *fp; char syscmd[MAX_RECONFIG_SIZE + LIFNAMSIZ]; char buf[MAX_RECONFIG_SIZE]; rcm_log_message(RCM_TRACE2, "IP: if_cfginfo(%s)\n", node->ip_resource); pif = node->ip_pif; lif = pif->pi_lifs; while (lif != NULL) { /* Make a list of modules pushed and save */ if (lif->li_ifnum == 0) { /* physical instance */ if (get_modlist(pif->pi_ifname, lif) == -1) { rcm_log_message(RCM_ERROR, _("IP: get modlist error (%s) %s\n"), pif->pi_ifname, strerror(errno)); clr_cfg_state(pif); return (-1); } if (!force) { /* Look if unknown modules have been inserted */ for (i = (lif->li_modcnt - 2); i > 0; i--) { if (modop(pif->pi_ifname, lif->li_modules[i], i, MOD_CHECK) == -1) { rcm_log_message(RCM_ERROR, _("IP: module %s@%d\n"), lif->li_modules[i], i); clr_cfg_state(pif); return (-1); } } } /* Last module is the device driver, so ignore that */ for (i = (lif->li_modcnt - 2); i > 0; i--) { rcm_log_message(RCM_TRACE2, "IP: modremove Pos = %d, Module = %s \n", i, lif->li_modules[i]); if (modop(pif->pi_ifname, lif->li_modules[i], i, MOD_REMOVE) == -1) { while (i != (lif->li_modcnt - 2)) { if (modop(pif->pi_ifname, lif->li_modules[i], i, MOD_INSERT) == -1) { /* Gross error */ rcm_log_message( RCM_ERROR, _("IP: if_cfginfo" "(%s) %s\n"), pif->pi_ifname, strerror(errno)); clr_cfg_state(pif); return (-1); } i++; } rcm_log_message( RCM_ERROR, _("IP: if_cfginfo(%s): modremove " "%s failed: %s\n"), pif->pi_ifname, lif->li_modules[i], strerror(errno)); clr_cfg_state(pif); return (-1); } } } /* Save reconfiguration information */ if (lif->li_ifflags & IFF_IPV4) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s:%d configinfo\n", SBIN_IFCONFIG, pif->pi_ifname, lif->li_ifnum); } else if (lif->li_ifflags & IFF_IPV6) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s:%d inet6 configinfo\n", SBIN_IFCONFIG, pif->pi_ifname, lif->li_ifnum); } rcm_log_message(RCM_TRACE2, "IP: %s\n", syscmd); /* open a pipe to retrieve reconfiguration info */ if ((fp = popen(syscmd, "r")) == NULL) { rcm_log_message(RCM_ERROR, _("IP: ifconfig configinfo error (%s:%d) %s\n"), pif->pi_ifname, lif->li_ifnum, strerror(errno)); clr_cfg_state(pif); return (-1); } bzero(buf, MAX_RECONFIG_SIZE); if (fgets(buf, MAX_RECONFIG_SIZE, fp) == NULL) { rcm_log_message(RCM_ERROR, _("IP: ifconfig configinfo error (%s:%d) %s\n"), pif->pi_ifname, lif->li_ifnum, strerror(errno)); (void) pclose(fp); clr_cfg_state(pif); return (-1); } (void) pclose(fp); if ((lif->li_reconfig = strdup(buf)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc error (%s) %s\n"), pif->pi_ifname, strerror(errno)); clr_cfg_state(pif); return (-1); } rcm_log_message(RCM_DEBUG, "IP: if_cfginfo: reconfig string(%s:%d) = %s\n", pif->pi_ifname, lif->li_ifnum, lif->li_reconfig); lif = lif->li_next; } return (0); } /* * if_unplumb() - Unplumb the interface * Save off the modlist, ifconfig options and unplumb. * Fail, if an unknown module lives between IP and driver and * force is not set * Call with cache_lock held */ static int if_unplumb(ip_cache_t *node) { ip_lif_t *lif; ip_pif_t *pif = node->ip_pif; boolean_t ipv4 = B_FALSE; boolean_t ipv6 = B_FALSE; rcm_log_message(RCM_TRACE2, "IP: if_unplumb(%s)\n", node->ip_resource); for (lif = pif->pi_lifs; lif != NULL; lif = lif->li_next) { if (lif->li_ifflags & IFF_IPV4) { ipv4 = B_TRUE; } else if (lif->li_ifflags & IFF_IPV6) { ipv6 = B_TRUE; } else { /* Unlikely case */ rcm_log_message(RCM_DEBUG, "IP: Unplumb ignored (%s:%d)\n", pif->pi_ifname, lif->li_ifnum); } } if (ipv4 && !ifconfig(pif->pi_ifname, "inet", "unplumb", B_FALSE)) { rcm_log_message(RCM_ERROR, _("IP: Cannot unplumb (%s) %s\n"), pif->pi_ifname, strerror(errno)); return (-1); } if (ipv6 && !ifconfig(pif->pi_ifname, "inet6", "unplumb", B_FALSE)) { rcm_log_message(RCM_ERROR, _("IP: Cannot unplumb (%s) %s\n"), pif->pi_ifname, strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE2, "IP: if_unplumb(%s) success\n", node->ip_resource); return (0); } /* * if_replumb() - Undo previous unplumb i.e. plumb back the physical interface * instances and the logical interfaces in order, restoring * all ifconfig options * Call with cache_lock held */ static int if_replumb(ip_cache_t *node) { ip_lif_t *lif; ip_pif_t *pif; int i; boolean_t success, ipmp; const char *fstr; char lifname[LIFNAMSIZ]; char buf[MAX_RECONFIG_SIZE]; int max_lifnum = 0; rcm_log_message(RCM_TRACE2, "IP: if_replumb(%s)\n", node->ip_resource); /* * Be extra careful about bringing up the interfaces in the * correct order: * - First plumb in the physical interface instances * - modinsert the necessary modules@pos * - Next, add the logical interfaces being careful about * the order, (follow the cached interface number li_ifnum order) */ pif = node->ip_pif; ipmp = (node->ip_pif->pi_grname[0] != '\0'); /* * Make a first pass to plumb in physical interfaces and get a count * of the max logical interfaces */ for (lif = pif->pi_lifs; lif != NULL; lif = lif->li_next) { max_lifnum = MAX(lif->li_ifnum, max_lifnum); if (lif->li_ifflags & IFF_IPV4) { fstr = "inet"; } else if (lif->li_ifflags & IFF_IPV6) { fstr = "inet6"; } else { /* Unlikely case */ rcm_log_message(RCM_DEBUG, "IP: Re-plumb ignored (%s:%d)\n", pif->pi_ifname, lif->li_ifnum); continue; } /* ignore logical interface instances */ if (lif->li_ifnum != 0) continue; if ((lif->li_ifflags & IFF_NOFAILOVER) || !ipmp) { success = ifconfig("", "", lif->li_reconfig, B_FALSE); } else { (void) snprintf(buf, sizeof (buf), "plumb group %s", pif->pi_grname); success = ifconfig(pif->pi_ifname, fstr, buf, B_FALSE); } if (!success) { rcm_log_message(RCM_ERROR, _("IP: Cannot plumb (%s) %s\n"), pif->pi_ifname, strerror(errno)); return (-1); } /* * Restart DHCP if necessary. */ if ((lif->li_ifflags & IFF_DHCPRUNNING) && !ifconfig(pif->pi_ifname, fstr, CFG_DHCP_CMD, B_FALSE)) { rcm_log_message(RCM_ERROR, _("IP: Cannot start DHCP " "(%s) %s\n"), pif->pi_ifname, strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE2, "IP: if_replumb: Modcnt = %d\n", lif->li_modcnt); /* modinsert modules in order, ignore driver(last) */ for (i = 0; i < (lif->li_modcnt - 1); i++) { rcm_log_message(RCM_TRACE2, "IP: modinsert: Pos = %d Mod = %s\n", i, lif->li_modules[i]); if (modop(pif->pi_ifname, lif->li_modules[i], i, MOD_INSERT) == -1) { rcm_log_message(RCM_ERROR, _("IP: modinsert error(%s)\n"), pif->pi_ifname); return (-1); } } } /* Now, add all the logical interfaces in the correct order */ for (i = 1; i <= max_lifnum; i++) { (void) snprintf(lifname, LIFNAMSIZ, "%s:%d", pif->pi_ifname, i); /* reset lif through every iteration */ for (lif = pif->pi_lifs; lif != NULL; lif = lif->li_next) { /* * Process entries in order. If the interface is * using IPMP, only process test addresses. */ if (lif->li_ifnum != i || (ipmp && !(lif->li_ifflags & IFF_NOFAILOVER))) continue; if (!ifconfig("", "", lif->li_reconfig, B_FALSE)) { rcm_log_message(RCM_ERROR, _("IP: Cannot addif (%s) %s\n"), lifname, strerror(errno)); return (-1); } /* * Restart DHCP if necessary. */ if ((lif->li_ifflags & IFF_DHCPRUNNING) && !ifconfig(lifname, fstr, CFG_DHCP_CMD, B_FALSE)) { rcm_log_message(RCM_ERROR, _("IP: Cannot start DHCP (%s) %s\n"), lifname, strerror(errno)); return (-1); } } } rcm_log_message(RCM_TRACE2, "IP: if_replumb(%s) success \n", node->ip_resource); return (0); } /* * clr_cfg_state() - Cleanup after errors in unplumb */ static void clr_cfg_state(ip_pif_t *pif) { ip_lif_t *lif; int i; lif = pif->pi_lifs; while (lif != NULL) { lif->li_modcnt = 0; free(lif->li_reconfig); lif->li_reconfig = NULL; for (i = 0; i < IP_MAX_MODS; i++) { free(lif->li_modules[i]); lif->li_modules[i] = NULL; } lif = lif->li_next; } } /* * Attempt to offline ip_cache_t `node'; returns an IPMP error code. */ static int ip_ipmp_offline(ip_cache_t *node) { int retval; ipmp_handle_t handle; rcm_log_message(RCM_TRACE1, "IP: ip_ipmp_offline\n"); if ((retval = ipmp_open(&handle)) != IPMP_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: cannot create ipmp handle: %s\n"), ipmp_errmsg(retval)); return (retval); } retval = ipmp_offline(handle, node->ip_pif->pi_ifname, node->ip_ifred); if (retval != IPMP_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: ipmp_offline error: %s\n"), ipmp_errmsg(retval)); } else { rcm_log_message(RCM_TRACE1, "IP: ipmp_offline success\n"); } ipmp_close(handle); return (retval); } /* * Attempt to undo the offline ip_cache_t `node'; returns an IPMP error code. */ static int ip_ipmp_undo_offline(ip_cache_t *node) { int retval; ipmp_handle_t handle; rcm_log_message(RCM_TRACE1, "IP: ip_ipmp_undo_offline\n"); if ((retval = ipmp_open(&handle)) != IPMP_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: cannot create ipmp handle: %s\n"), ipmp_errmsg(retval)); return (retval); } retval = ipmp_undo_offline(handle, node->ip_pif->pi_ifname); if (retval != IPMP_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: ipmp_undo_offline error: %s\n"), ipmp_errmsg(retval)); } else { rcm_log_message(RCM_TRACE1, "IP: ipmp_undo_offline success\n"); } ipmp_close(handle); return (retval); } /* * get_link_resource() - Convert a link name (e.g., net0, hme1000) into a * dynamically allocated string containing the associated link resource * name ("SUNW_datalink/"). */ static char * get_link_resource(const char *link) { char errmsg[DLADM_STRSIZE]; datalink_id_t linkid; uint32_t flags; char *resource; dladm_status_t status; status = dladm_name2info(dld_handle, link, &linkid, &flags, NULL, NULL); if (status != DLADM_STATUS_OK) goto fail; if (!(flags & DLADM_OPT_ACTIVE)) { status = DLADM_STATUS_FAILED; goto fail; } resource = malloc(RCM_LINK_RESOURCE_MAX); if (resource == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc error(%s): %s\n"), strerror(errno), link); return (NULL); } (void) snprintf(resource, RCM_LINK_RESOURCE_MAX, "%s/%u", RCM_LINK_PREFIX, linkid); return (resource); fail: rcm_log_message(RCM_ERROR, _("IP: get_link_resource for %s error(%s)\n"), link, dladm_status2str(status, errmsg)); return (NULL); } /* * modop() - Remove/insert a module */ static int modop(char *name, char *arg, int pos, char op) { char syscmd[LIFNAMSIZ+MAXPATHLEN]; /* must be big enough */ rcm_log_message(RCM_TRACE1, "IP: modop(%s)\n", name); /* Nothing to do with "ip", "arp" */ if ((arg == NULL) || (strcmp(arg, "") == 0) || STREQ(arg, IP_MOD_NAME) || STREQ(arg, ARP_MOD_NAME)) { rcm_log_message(RCM_TRACE1, "IP: modop success\n"); return (0); } if (op == MOD_CHECK) { /* * No known good modules (yet) apart from ip and arp * which are handled above */ return (-1); } if (op == MOD_REMOVE) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s modremove %s@%d\n", SBIN_IFCONFIG, name, arg, pos); } else if (op == MOD_INSERT) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s modinsert %s@%d\n", SBIN_IFCONFIG, name, arg, pos); } else { rcm_log_message(RCM_ERROR, _("IP: modop(%s): unknown operation\n"), name); return (-1); } rcm_log_message(RCM_TRACE1, "IP: modop(%s): %s\n", name, syscmd); if (rcm_exec_cmd(syscmd) == -1) { rcm_log_message(RCM_ERROR, _("IP: modop(%s): %s\n"), name, strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE1, "IP: modop success\n"); return (0); } /* * get_modlist() - return a list of pushed mid-stream modules * Required memory is malloced to construct the list, * Caller must free this memory list * Call with cache_lock held */ static int get_modlist(char *name, ip_lif_t *lif) { int mux_fd; int muxid_fd; int fd; int i; int num_mods; struct lifreq lifr; struct str_list strlist = { 0 }; rcm_log_message(RCM_TRACE1, "IP: getmodlist(%s)\n", name); (void) strlcpy(lifr.lifr_name, name, sizeof (lifr.lifr_name)); lifr.lifr_flags = lif->li_ifflags; if (ip_domux2fd(&mux_fd, &muxid_fd, &fd, &lifr) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd(%s)\n"), name); return (-1); } if ((num_mods = ioctl(fd, I_LIST, NULL)) < 0) { rcm_log_message(RCM_ERROR, _("IP: get_modlist(%s): I_LIST(%s) \n"), name, strerror(errno)); goto fail; } strlist.sl_nmods = num_mods; strlist.sl_modlist = malloc(sizeof (struct str_mlist) * num_mods); if (strlist.sl_modlist == NULL) { rcm_log_message(RCM_ERROR, _("IP: get_modlist(%s): %s\n"), name, strerror(errno)); goto fail; } if (ioctl(fd, I_LIST, (caddr_t)&strlist) < 0) { rcm_log_message(RCM_ERROR, _("IP: get_modlist(%s): I_LIST error: %s\n"), name, strerror(errno)); goto fail; } for (i = 0; i < strlist.sl_nmods; i++) { lif->li_modules[i] = strdup(strlist.sl_modlist[i].l_name); if (lif->li_modules[i] == NULL) { rcm_log_message(RCM_ERROR, _("IP: get_modlist(%s): %s\n"), name, strerror(errno)); while (i > 0) free(lif->li_modules[--i]); goto fail; } } lif->li_modcnt = strlist.sl_nmods; free(strlist.sl_modlist); rcm_log_message(RCM_TRACE1, "IP: getmodlist(%s) success\n", name); return (ip_plink(mux_fd, muxid_fd, fd, &lifr)); fail: free(strlist.sl_modlist); (void) ip_plink(mux_fd, muxid_fd, fd, &lifr); return (-1); } /* * ip_domux2fd() - Helper function for mod*() functions * Stolen from ifconfig.c */ static int ip_domux2fd(int *mux_fd, int *muxid_fdp, int *fd, struct lifreq *lifr) { int muxid_fd; char *udp_dev_name; if (lifr->lifr_flags & IFF_IPV6) { udp_dev_name = UDP6_DEV_NAME; } else { udp_dev_name = UDP_DEV_NAME; } if ((muxid_fd = open(udp_dev_name, O_RDWR)) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd: open(%s) %s\n"), udp_dev_name, strerror(errno)); return (-1); } if ((*mux_fd = open(udp_dev_name, O_RDWR)) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd: open(%s) %s\n"), udp_dev_name, strerror(errno)); (void) close(muxid_fd); return (-1); } if (ioctl(muxid_fd, SIOCGLIFMUXID, (caddr_t)lifr) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd: SIOCGLIFMUXID(%s): %s\n"), udp_dev_name, strerror(errno)); (void) close(*mux_fd); (void) close(muxid_fd); return (-1); } rcm_log_message(RCM_TRACE2, "IP: ip_domux2fd: ARP_muxid %d IP_muxid %d\n", lifr->lifr_arp_muxid, lifr->lifr_ip_muxid); if ((*fd = ioctl(*mux_fd, _I_MUXID2FD, lifr->lifr_ip_muxid)) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd: _I_MUXID2FD(%s): %s\n"), udp_dev_name, strerror(errno)); (void) close(*mux_fd); (void) close(muxid_fd); return (-1); } if (ioctl(*mux_fd, I_PUNLINK, lifr->lifr_ip_muxid) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_domux2fd: I_PUNLINK(%s): %s\n"), udp_dev_name, strerror(errno)); (void) close(*mux_fd); (void) close(muxid_fd); return (-1); } /* Note: mux_fd and muxid_fd are closed in ip_plink below */ *muxid_fdp = muxid_fd; return (0); } /* * ip_plink() - Helper function for mod*() functions. * Stolen from ifconfig.c */ static int ip_plink(int mux_fd, int muxid_fd, int fd, struct lifreq *lifr) { int mux_id; if ((mux_id = ioctl(mux_fd, I_PLINK, fd)) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_plink I_PLINK(%s): %s\n"), UDP_DEV_NAME, strerror(errno)); (void) close(mux_fd); (void) close(muxid_fd); (void) close(fd); return (-1); } lifr->lifr_ip_muxid = mux_id; if (ioctl(muxid_fd, SIOCSLIFMUXID, (caddr_t)lifr) < 0) { rcm_log_message(RCM_ERROR, _("IP: ip_plink SIOCSLIFMUXID(%s): %s\n"), UDP_DEV_NAME, strerror(errno)); (void) close(mux_fd); (void) close(muxid_fd); (void) close(fd); return (-1); } (void) close(mux_fd); (void) close(muxid_fd); (void) close(fd); return (0); } /* * ip_onlinelist() * * Notify online to IP address consumers. */ /*ARGSUSED*/ static int ip_onlinelist(rcm_handle_t *hd, ip_cache_t *node, char **errorp, uint_t flags, rcm_info_t **depend_info) { char **addrlist; int ret = RCM_SUCCESS; rcm_log_message(RCM_TRACE2, "IP: ip_onlinelist\n"); addrlist = ip_get_addrlist(node); if (addrlist == NULL || addrlist[0] == NULL) { rcm_log_message(RCM_TRACE2, "IP: ip_onlinelist none\n"); ip_free_addrlist(addrlist); return (ret); } ret = rcm_notify_online_list(hd, addrlist, 0, depend_info); ip_free_addrlist(addrlist); rcm_log_message(RCM_TRACE2, "IP: ip_onlinelist done\n"); return (ret); } /* * ip_offlinelist() * * Offline IP address consumers. */ /*ARGSUSED*/ static int ip_offlinelist(rcm_handle_t *hd, ip_cache_t *node, char **errorp, uint_t flags, rcm_info_t **depend_info) { char **addrlist; int ret = RCM_SUCCESS; rcm_log_message(RCM_TRACE2, "IP: ip_offlinelist\n"); addrlist = ip_get_addrlist(node); if (addrlist == NULL || addrlist[0] == NULL) { rcm_log_message(RCM_TRACE2, "IP: ip_offlinelist none\n"); ip_free_addrlist(addrlist); return (RCM_SUCCESS); } if ((ret = rcm_request_offline_list(hd, addrlist, flags, depend_info)) != RCM_SUCCESS) { if (ret == RCM_FAILURE) (void) rcm_notify_online_list(hd, addrlist, 0, NULL); ret = RCM_FAILURE; } ip_free_addrlist(addrlist); rcm_log_message(RCM_TRACE2, "IP: ip_offlinelist done\n"); return (ret); } /* * ip_get_addrlist() - Get the list of IP addresses on this interface (node); * This routine malloc()s required memory for the list. * Returns the list on success, NULL on failure. * Call with cache_lock held. */ static char ** ip_get_addrlist(ip_cache_t *node) { ip_lif_t *lif; char **addrlist = NULL; int i, numifs; size_t addrlistsize; char addrstr[INET6_ADDRSTRLEN]; rcm_log_message(RCM_TRACE2, "IP: ip_get_addrlist(%s)\n", node->ip_resource); numifs = 0; for (lif = node->ip_pif->pi_lifs; lif != NULL; lif = lif->li_next) { numifs++; } /* * Allocate space for resource names list; add 1 and use calloc() * so that the list is NULL-terminated. */ if ((addrlist = calloc(numifs + 1, sizeof (char *))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: ip_get_addrlist(%s) malloc failure(%s)\n"), node->ip_resource, strerror(errno)); return (NULL); } for (lif = node->ip_pif->pi_lifs, i = 0; lif != NULL; lif = lif->li_next, i++) { if (!ip_addrstr(lif, addrstr, sizeof (addrstr))) { ip_free_addrlist(addrlist); return (NULL); } addrlistsize = strlen(addrstr) + sizeof (RCM_STR_SUNW_IP); if ((addrlist[i] = malloc(addrlistsize)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: ip_get_addrlist(%s) malloc failure(%s)\n"), node->ip_resource, strerror(errno)); ip_free_addrlist(addrlist); return (NULL); } (void) snprintf(addrlist[i], addrlistsize, "%s%s", RCM_STR_SUNW_IP, addrstr); rcm_log_message(RCM_DEBUG, "Anon Address: %s\n", addrlist[i]); } rcm_log_message(RCM_TRACE2, "IP: get_addrlist (%s) done\n", node->ip_resource); return (addrlist); } static void ip_free_addrlist(char **addrlist) { int i; if (addrlist == NULL) return; for (i = 0; addrlist[i] != NULL; i++) free(addrlist[i]); free(addrlist); } /* * ip_consumer_notify() - Notify consumers of IP addresses coming back online. */ static void ip_consumer_notify(rcm_handle_t *hd, datalink_id_t linkid, char **errorp, uint_t flags, rcm_info_t **depend_info) { char cached_name[RCM_LINK_RESOURCE_MAX]; ip_cache_t *node; assert(linkid != DATALINK_INVALID_LINKID); rcm_log_message(RCM_TRACE1, _("IP: ip_consumer_notify(%u)\n"), linkid); /* Check for the interface in the cache */ (void) snprintf(cached_name, sizeof (cached_name), "%s/%u", RCM_LINK_PREFIX, linkid); (void) mutex_lock(&cache_lock); if ((node = cache_lookup(hd, cached_name, CACHE_REFRESH)) == NULL) { rcm_log_message(RCM_TRACE1, _("IP: Skipping interface(%u)\n"), linkid); (void) mutex_unlock(&cache_lock); return; } /* * Inform anonymous consumers about IP addresses being onlined. */ (void) ip_onlinelist(hd, node, errorp, flags, depend_info); (void) mutex_unlock(&cache_lock); rcm_log_message(RCM_TRACE2, "IP: ip_consumer_notify success\n"); } /* * Gets the interface name for the given linkid. Returns -1 if there is * any error. It fills in the interface name in `ifinst' if the interface * is not already configured. Otherwise, it puts a null string in `ifinst'. */ static int if_configure_get_linkid(datalink_id_t linkid, char *ifinst, size_t len) { char cached_name[RCM_LINK_RESOURCE_MAX]; ip_cache_t *node; /* Check for the interface in the cache */ (void) snprintf(cached_name, sizeof (cached_name), "%s/%u", RCM_LINK_PREFIX, linkid); /* Check if the interface is new or was not previously offlined */ (void) mutex_lock(&cache_lock); if (((node = cache_lookup(NULL, cached_name, CACHE_REFRESH)) != NULL) && (!(node->ip_cachestate & CACHE_IF_OFFLINED))) { rcm_log_message(RCM_TRACE1, _("IP: Skipping configured interface(%u)\n"), linkid); (void) mutex_unlock(&cache_lock); *ifinst = '\0'; return (0); } (void) mutex_unlock(&cache_lock); if (dladm_datalink_id2info(dld_handle, linkid, NULL, NULL, NULL, ifinst, len) != DLADM_STATUS_OK) { rcm_log_message(RCM_ERROR, _("IP: get %u link name failed\n"), linkid); return (-1); } return (0); } /* * if_configure_hostname() - Configure a physical interface after attach * based on the information in /etc/hostname.* */ static int if_configure_hostname(datalink_id_t linkid) { FILE *hostfp, *host6fp; boolean_t ipmp = B_FALSE; char ifinst[MAXLINKNAMELEN]; char cfgfile[MAXPATHLEN]; assert(linkid != DATALINK_INVALID_LINKID); rcm_log_message(RCM_TRACE1, _("IP: if_configure_hostname(%u)\n"), linkid); if (if_configure_get_linkid(linkid, ifinst, sizeof (ifinst)) != 0) return (-1); /* Check if the interface is already configured. */ if (ifinst[0] == '\0') return (0); /* * Scan the IPv4 and IPv6 hostname files to see if (a) they exist * and (b) if either one places the interface into an IPMP group. */ (void) snprintf(cfgfile, MAXPATHLEN, CFGFILE_FMT_IPV4, ifinst); rcm_log_message(RCM_TRACE1, "IP: Scanning %s\n", cfgfile); if ((hostfp = fopen(cfgfile, "r")) != NULL) { if (isgrouped(cfgfile)) ipmp = B_TRUE; } (void) snprintf(cfgfile, MAXPATHLEN, CFGFILE_FMT_IPV6, ifinst); rcm_log_message(RCM_TRACE1, "IP: Scanning %s\n", cfgfile); if ((host6fp = fopen(cfgfile, "r")) != NULL) { if (!ipmp && isgrouped(cfgfile)) ipmp = B_TRUE; } /* * Configure the interface according to its hostname files. */ if (hostfp != NULL && if_config_inst(ifinst, hostfp, AF_INET, ipmp) == -1) { rcm_log_message(RCM_ERROR, _("IP: IPv4 Post-attach failed (%s)\n"), ifinst); goto fail; } if (host6fp != NULL && if_config_inst(ifinst, host6fp, AF_INET6, ipmp) == -1) { rcm_log_message(RCM_ERROR, _("IP: IPv6 Post-attach failed (%s)\n"), ifinst); goto fail; } (void) fclose(hostfp); (void) fclose(host6fp); rcm_log_message(RCM_TRACE1, "IP: if_configure_hostname(%s) success\n", ifinst); return (0); fail: (void) fclose(hostfp); (void) fclose(host6fp); return (-1); } /* * if_configure_ipadm() - Configure a physical interface after attach * Queries libipadm for persistent configuration information and then * resurrects that persistent configuration. */ static int if_configure_ipadm(datalink_id_t linkid) { char ifinst[MAXLINKNAMELEN]; boolean_t found; ipadm_if_info_t *ifinfo, *ptr; ipadm_status_t status; assert(linkid != DATALINK_INVALID_LINKID); rcm_log_message(RCM_TRACE1, _("IP: if_configure_ipadm(%u)\n"), linkid); if (if_configure_get_linkid(linkid, ifinst, sizeof (ifinst)) != 0) return (-1); /* Check if the interface is already configured. */ if (ifinst[0] == '\0') return (0); status = ipadm_if_info(ip_handle, ifinst, &ifinfo, 0, LIFC_UNDER_IPMP); if (status == IPADM_ENXIO) goto done; if (status != IPADM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: IPv4 Post-attach failed (%s) Error %s\n"), ifinst, ipadm_status2str(status)); goto fail; } if (ifinfo != NULL) { found = B_FALSE; for (ptr = ifinfo; ptr != NULL; ptr = ptr->ifi_next) { if (strncmp(ptr->ifi_name, ifinst, sizeof (ifinst)) == 0) { found = B_TRUE; break; } } ipadm_free_if_info(ifinfo); if (!found) { return (0); } if (if_hostname_exists(ifinst, AF_INET) || if_hostname_exists(ifinst, AF_INET6)) { rcm_log_message(RCM_WARNING, _("IP: IPv4 Post-attach (%s) found both " "/etc/hostname and ipadm persistent configuration. " "Ignoring ipadm config\n"), ifinst); return (0); } status = ipadm_enable_if(ip_handle, ifinst, IPADM_OPT_ACTIVE); if (status != IPADM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: Post-attach failed (%s) Error %s\n"), ifinst, ipadm_status2str(status)); goto fail; } } done: rcm_log_message(RCM_TRACE1, "IP: if_configure_ipadm(%s) success\n", ifinst); return (0); fail: return (-1); } /* * isgrouped() - Scans the given config file to see if this interface is * using IPMP. Returns B_TRUE or B_FALSE. */ static boolean_t isgrouped(const char *cfgfile) { FILE *fp; struct stat statb; char *nlp, *line, *token, *lasts, *buf; boolean_t grouped = B_FALSE; rcm_log_message(RCM_TRACE1, "IP: isgrouped(%s)\n", cfgfile); if (stat(cfgfile, &statb) != 0) { rcm_log_message(RCM_TRACE1, _("IP: No config file(%s)\n"), cfgfile); return (B_FALSE); } /* * We also ignore single-byte config files because the file should * always be newline-terminated, so we know there's nothing of * interest. Further, a single-byte file would cause the fgets() loop * below to spin forever. */ if (statb.st_size <= 1) { rcm_log_message(RCM_TRACE1, _("IP: Empty config file(%s)\n"), cfgfile); return (B_FALSE); } if ((fp = fopen(cfgfile, "r")) == NULL) { rcm_log_message(RCM_ERROR, _("IP: Cannot open configuration file(%s): %s\n"), cfgfile, strerror(errno)); return (B_FALSE); } if ((buf = malloc(statb.st_size)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc failure(%s): %s\n"), cfgfile, strerror(errno)); goto out; } while (fgets(buf, statb.st_size, fp) != NULL) { if ((nlp = strrchr(buf, '\n')) != NULL) *nlp = '\0'; line = buf; while ((token = strtok_r(line, " \t", &lasts)) != NULL) { line = NULL; if (STREQ("group", token) && strtok_r(NULL, " \t", &lasts) != NULL) { grouped = B_TRUE; goto out; } } } out: free(buf); (void) fclose(fp); rcm_log_message(RCM_TRACE1, "IP: isgrouped(%s): %d\n", cfgfile, grouped); return (grouped); } /* * if_config_inst() - Configure an interface instance as specified by the * address family af and if it is grouped (ipmp). */ static int if_config_inst(const char *ifinst, FILE *hfp, int af, boolean_t ipmp) { FILE *ifparsefp; struct stat statb; char *buf = NULL; char *ifparsebuf = NULL; uint_t ifparsebufsize; const char *fstr; /* address family string */ boolean_t stdif = B_FALSE; rcm_log_message(RCM_TRACE1, "IP: if_config_inst(%s) ipmp = %d\n", ifinst, ipmp); if (fstat(fileno(hfp), &statb) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot fstat file(%s)\n"), ifinst); goto fail; } switch (af) { case AF_INET: fstr = "inet"; break; case AF_INET6: fstr = "inet6"; break; default: assert(0); } /* * The hostname file exists; plumb the physical interface. */ if (!ifconfig(ifinst, fstr, "plumb", B_FALSE)) goto fail; /* Skip static configuration if the hostname file is empty */ if (statb.st_size <= 1) { rcm_log_message(RCM_TRACE1, _("IP: Zero size hostname file(%s)\n"), ifinst); goto configured; } if (fseek(hfp, 0, SEEK_SET) == -1) { rcm_log_message(RCM_ERROR, _("IP: Cannot rewind hostname file(%s): %s\n"), ifinst, strerror(errno)); goto fail; } /* * Allocate the worst-case single-line buffer sizes. A bit skanky, * but since hostname files are small, this should suffice. */ if ((buf = calloc(1, statb.st_size)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc(%s): %s\n"), ifinst, strerror(errno)); goto fail; } ifparsebufsize = statb.st_size + sizeof (SBIN_IFPARSE " -s inet6 "); if ((ifparsebuf = calloc(1, ifparsebufsize)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc(%s): %s\n"), ifinst, strerror(errno)); goto fail; } /* * For IPv4, determine whether the hostname file consists of a single * line. We need to handle these specially since they should * automatically be suffixed with "netmask + broadcast + up". */ if (af == AF_INET && fgets(buf, statb.st_size, hfp) != NULL && fgets(buf, statb.st_size, hfp) == NULL) { rcm_log_message(RCM_TRACE1, "IP: one-line hostname file\n"); stdif = B_TRUE; } if (fseek(hfp, 0L, SEEK_SET) == -1) { rcm_log_message(RCM_ERROR, _("IP: Cannot rewind hostname file(%s): %s\n"), ifinst, strerror(errno)); goto fail; } /* * Loop through the file one line at a time and feed it to ifconfig. * If the interface is using IPMP, then we use /sbin/ifparse -s to * weed out all of the data addresses, since those are already on the * IPMP meta-interface. */ while (fgets(buf, statb.st_size, hfp) != NULL) { if (ntok(buf) == 0) continue; if (!ipmp) { (void) ifconfig(ifinst, fstr, buf, stdif); continue; } (void) snprintf(ifparsebuf, ifparsebufsize, SBIN_IFPARSE " -s %s %s", fstr, buf); if ((ifparsefp = popen(ifparsebuf, "r")) == NULL) { rcm_log_message(RCM_ERROR, _("IP: cannot configure %s: popen \"%s\" " "failed: %s\n"), ifinst, buf, strerror(errno)); goto fail; } while (fgets(buf, statb.st_size, ifparsefp) != NULL) { if (ntok(buf) > 0) (void) ifconfig(ifinst, fstr, buf, stdif); } if (pclose(ifparsefp) == -1) { rcm_log_message(RCM_ERROR, _("IP: cannot configure %s: pclose \"%s\" " "failed: %s\n"), ifinst, buf, strerror(errno)); goto fail; } } configured: /* * Bring up the interface (it may already be up) * * Technically, since the boot scripts only unconditionally bring up * IPv6 interfaces, we should only unconditionally bring up IPv6 here. * However, if we don't bring up IPv4, and a legacy IPMP configuration * without test addresses is being used, we will never bring the * interface up even though we would've at boot. One fix is to check * if the IPv4 hostname file contains data addresses that we would've * brought up, but there's no simple way to do that. Given that it's * rare to have persistent IP configuration for an interface that * leaves it down, we cheap out and always bring it up for IPMP. */ if ((af == AF_INET6 || ipmp) && !ifconfig(ifinst, fstr, "up", B_FALSE)) goto fail; /* * For IPv4, if a DHCP configuration file exists, have DHCP configure * the interface. As with the boot scripts, this is done after the * hostname files are processed so that configuration in those files * (such as IPMP group names) will be applied first. */ if (af == AF_INET) { char dhcpfile[MAXPATHLEN]; char *dhcpbuf; off_t i, dhcpsize; (void) snprintf(dhcpfile, MAXPATHLEN, DHCPFILE_FMT, ifinst); if (stat(dhcpfile, &statb) == -1) goto out; if ((dhcpbuf = copylist(dhcpfile, &dhcpsize)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: cannot read " "(%s): %s\n"), dhcpfile, strerror(errno)); goto fail; } /* * The copylist() API converts \n's to \0's, but we want them * to be spaces. */ if (dhcpsize > 0) { for (i = 0; i < dhcpsize; i++) if (dhcpbuf[i] == '\0') dhcpbuf[i] = ' '; dhcpbuf[dhcpsize - 1] = '\0'; } (void) ifconfig(ifinst, CFG_DHCP_CMD, dhcpbuf, B_FALSE); free(dhcpbuf); } out: free(ifparsebuf); free(buf); rcm_log_message(RCM_TRACE1, "IP: if_config_inst(%s) success\n", ifinst); return (0); fail: free(ifparsebuf); free(buf); rcm_log_message(RCM_ERROR, "IP: if_config_inst(%s) failure\n", ifinst); return (-1); } /* * ntok() - count the number of tokens in the provided buffer. */ static uint_t ntok(const char *cp) { uint_t ntok = 0; for (;;) { while (ISSPACE(*cp)) cp++; if (ISEOL(*cp)) break; do { cp++; } while (!ISSPACE(*cp) && !ISEOL(*cp)); ntok++; } return (ntok); } static boolean_t ifconfig(const char *ifinst, const char *fstr, const char *buf, boolean_t stdif) { char syscmd[MAX_RECONFIG_SIZE + MAXPATHLEN + 1]; int status; (void) snprintf(syscmd, sizeof (syscmd), SBIN_IFCONFIG " %s %s %s", ifinst, fstr, buf); if (stdif) (void) strlcat(syscmd, CFG_CMDS_STD, sizeof (syscmd)); rcm_log_message(RCM_TRACE1, "IP: Exec: %s\n", syscmd); if ((status = rcm_exec_cmd(syscmd)) != 0) { if (WIFEXITED(status)) { rcm_log_message(RCM_ERROR, _("IP: \"%s\" failed with " "exit status %d\n"), syscmd, WEXITSTATUS(status)); } else { rcm_log_message(RCM_ERROR, _("IP: Error: %s: %s\n"), syscmd, strerror(errno)); } return (B_FALSE); } return (B_TRUE); } /* * Return TRUE if a writeable /etc/hostname[6].ifname file exists. */ static boolean_t if_hostname_exists(char *ifname, sa_family_t af) { char cfgfile[MAXPATHLEN]; if (af == AF_INET) { (void) snprintf(cfgfile, MAXPATHLEN, CFGFILE_FMT_IPV4, ifname); if (access(cfgfile, W_OK|F_OK) == 0) return (B_TRUE); } else if (af == AF_INET6) { (void) snprintf(cfgfile, MAXPATHLEN, CFGFILE_FMT_IPV6, ifname); if (access(cfgfile, W_OK|F_OK) == 0) return (B_TRUE); } return (B_FALSE); }