/* * 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 2007 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * 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 "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_NET_PREFIX "SUNW_network" /* RCM network name prefix */ #define RCM_NET_RESOURCE_MAX (13 + LIFNAMSIZ) /* RCM_NET_PREFIX+LIFNAMSIZ */ #define RCM_STR_SUNW_IP "SUNW_ip/" /* IP address export prefix */ #define RCM_SIZE_SUNW_IP 9 /* strlen("SUNW_ip/") + 1 */ /* ifconfig(1M) */ #define USR_SBIN_IFCONFIG "/usr/sbin/ifconfig" /* ifconfig command */ #define CFGFILE_FMT_IPV4 "/etc/hostname." /* IPV4 config file */ #define CFGFILE_FMT_IPV6 "/etc/hostname6." /* IPV6 config file */ #define CFG_CMDS_STD " netmask + broadcast + up" /* Normal config string */ #define CONFIG_AF_INET 0x1 /* Post-configure IPv4 */ #define CONFIG_AF_INET6 0x2 /* Post-configure IPv6 */ #define MAXLINE 1024 /* Max. line length */ #define MAXARGS 512 /* Max. args in ifconfig cmd */ /* Physical interface flags mask */ #define RCM_PIF_FLAGS (IFF_OFFLINE | IFF_INACTIVE | IFF_FAILED | \ IFF_STANDBY) /* Some useful macros */ #ifndef MAX #define MAX(a, b) (((a) > (b))?(a):(b)) #endif /* MAX */ #ifndef ISSPACE #define ISSPACE(c) ((c) == ' ' || (c) == '\t') #endif #ifndef ISEOL #define ISEOL(c) ((c) == '\n' || (c) == '\r' || (c) == '\0') #endif #ifndef STREQ #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0) #endif #ifndef ADDSPACE #define ADDSPACE(a) ((void) strcat((a), " ")) #endif /* 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 */ /* in.mpathd(1M) specifics */ #define MPATHD_MAX_RETRIES 5 /* Max. offline retries */ /* 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 */ /* VLAN format support */ #define VLAN_MAX_PPA_ALLOWED 1000 #define VLAN_GET_PPA(ppa) (ppa % VLAN_MAX_PPA_ALLOWED) /* devfsadm attach nvpair values */ #define PROP_NV_DDI_NETWORK "ddi_network" /* * in.mpathd(1M) message passing formats */ typedef struct mpathd_cmd { uint32_t cmd_command; /* message command */ char cmd_ifname[LIFNAMSIZ]; /* this interface name */ char cmd_movetoif[LIFNAMSIZ]; /* move to interface */ uint32_t cmd_min_red; /* min. redundancy */ /* Message passing values for MI_SETOINDEX */ #define from_lifname cmd_ifname /* current logical interface */ #define to_pifname cmd_movetoif /* new physical interface */ #define addr_family cmd_min_red /* address family */ } mpathd_cmd_t; /* This is needed since mpathd checks message size for offline */ typedef struct mpathd_unoffline { uint32_t cmd_command; /* offline / undo offline */ char cmd_ifname[LIFNAMSIZ]; /* this interface name */ } mpathd_unoffline_t; typedef struct mpathd_response { uint32_t resp_sys_errno; /* system errno */ uint32_t resp_mpathd_err; /* mpathd error information */ } mpathd_response_t; /* * IP module data types */ /* Physical interface representation */ typedef struct ip_pif { char pi_ifname[LIFNAMSIZ+1]; /* interface name */ char pi_grpname[LIFNAMSIZ+1]; /* 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; /* * Global NIC list to be configured after DR-attach */ #define NIL_NULL ((struct ni_list *)0) struct net_interface { char *type; /* Name of type of interface (le, ie, etc.) */ char *name; /* Qualified name of interface (le0, ie0, etc.) */ }; struct ni_list { struct net_interface *nifp; struct ni_list *next; }; static mutex_t nil_lock; /* NIC list lock */ static int num_ni = 0; /* Global new interface count */ static struct ni_list *nil_head = NIL_NULL; /* Global new if list */ struct devfs_minor_data { int32_t minor_type; char *minor_name; char *minor_node_type; }; /* * 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 lifreq *); static int ip_ipmp_offline(ip_cache_t *, 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_physical_resource(const char *); static void clr_cfg_state(ip_pif_t *); static uint64_t if_get_flags(ip_pif_t *); static int mpathd_send_cmd(mpathd_cmd_t *); static int connect_to_mpathd(int); 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 *, char *, char **, uint_t, rcm_info_t **); static int process_nvlist(nvlist_t *); static void process_minor(char *, char *, int32_t, struct devfs_minor_data *); static int if_configure(char *); static int isgrouped(char *); static int if_ipmp_config(char *, int, int); static int if_mpathd_configure(char *, char *, int, int); static char *get_mpathd_dest(char *, int); static int if_getcount(int); static void tokenize(char *, char **, char *, int *); /* 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) { 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, NULL, NULL); (void) mutex_init(&nil_lock, NULL, 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 %I%"); } /* * 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(&nil_lock); (void) mutex_destroy(&cache_lock); 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_NETWORK_NEW, 0, NULL) != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: failed to register %s\n"), RCM_RESOURCE_NETWORK_NEW); return (RCM_FAILURE); } else { rcm_log_message(RCM_DEBUG, "IP: registered %s\n", RCM_RESOURCE_NETWORK_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_NETWORK_NEW, 0) != RCM_SUCCESS) { rcm_log_message(RCM_ERROR, _("IP: failed to unregister %s\n"), RCM_RESOURCE_NETWORK_NEW); return (RCM_FAILURE); } else { rcm_log_message(RCM_DEBUG, "IP: unregistered %s\n", RCM_RESOURCE_NETWORK_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; int detachable = 0; int nofailover = 0; int ipmp = 0; 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++; } /* Check if the interface is an IPMP grouped interface */ if (strcmp(pif->pi_grpname, "")) { ipmp++; } if (if_get_flags(pif) & IFF_NOFAILOVER) { nofailover++; } /* * Even if the interface is not in an IPMP group, 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); } } /* * Cannot remove an IPMP interface if IFF_NOFAILOVER is set. */ if (ipmp && nofailover) { /* Interface is part of an IPMP group, and cannot failover */ ip_log_err(node, errorp, "Failover disabled"); errno = EBUSY; (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 an IPMP interface that can be failed over. * Request in.mpathd(1M) to failover the physical interface. */ /* Failover to "any", let mpathd determine best failover candidate */ if (ip_ipmp_offline(node, NULL) < 0) { ip_log_err(node, errorp, "in.mpathd failover failed"); /* * Odds are that in.mpathd(1M) 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. * * TODO: change ip_ipmp_offline() to return the actual failure * from in.mpathd so that we can verify that it did indeed * fail with IPMP_EMINRED. */ if (!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); errno = EBUSY; return (RCM_FAILURE); } } } if (if_unplumb(node) < 0) { rcm_log_message(RCM_ERROR, _("IP: Unplumb failed (%s)\n"), pif->pi_ifname); /* Request mpathd to undo the offline */ if (ip_ipmp_undo_offline(node) < 0) { 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) { struct ni_list *nilp, *onilp; struct net_interface *nip; int n; 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_NETWORK_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); } /* Process the nvlist for the event */ if (process_nvlist(nvl) != 0) { rcm_log_message(RCM_WARNING, _("IP: Error processing resource attributes(%s)\n"), rsrc); rcm_log_message(RCM_WARNING, _("IP: One or more devices may not be configured.\n")); ip_log_err(NULL, errorp, "Error processing device properties"); /* Continue processing interfaces that were valid */ } (void) mutex_lock(&nil_lock); /* Configure all new interfaces found */ for (nilp = nil_head, n = 0; n < num_ni; nilp = nilp->next, n++) { nip = nilp->nifp; if (if_configure(nip->name) != 0) { rcm_log_message(RCM_ERROR, _("IP: Configuration failed (%s)\n"), nip->name); ip_log_err(NULL, errorp, "Failed configuring one or more IP addresses"); /* continue configuring rest of the interfaces */ } } /* Notify all IP address consumers and clean up interface list */ for (nilp = nil_head; nilp; ) { nip = nilp->nifp; if (nip != (struct net_interface *)0) { if (nip->name != 0) { ip_consumer_notify(hd, nip->name, errorp, flags, depend_info); free(nip->name); } if (nip->type != 0) free(nip->type); free((char *)nip); } onilp = nilp; nilp = nilp->next; free((char *)onilp); } num_ni = 0; /* reset new if count */ nil_head = NIL_NULL; /* reset list head */ (void) mutex_unlock(&nil_lock); 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; int numifs; char *buf; char *nic; const char *fmt; char *sep; char addrstr[INET6_ADDRSTRLEN]; int offline = 0; size_t bufsz; rcm_log_message(RCM_TRACE2, "IP: usage(%s)\n", node->ip_resource); nic = strchr(node->ip_resource, '/'); nic = nic ? nic + 1 : node->ip_resource; /* TRANSLATION_NOTE: separator used between IP addresses */ sep = _(", "); numifs = 0; for (lif = node->ip_pif->pi_lifs; lif != NULL; lif = lif->li_next) { if (lif->li_ifflags & IFF_UP) { numifs++; } } if (node->ip_cachestate & CACHE_IF_OFFLINED) { offline++; } if (!offline && numifs) { fmt = _("%1$s hosts IP addresses: "); } else if (offline) { fmt = _("%1$s offlined"); } else { fmt = _("%1$s plumbed but down"); } /* space for addresses and separators, plus message */ bufsz = ((numifs * (INET6_ADDRSTRLEN + strlen(sep))) + strlen(fmt) + strlen(nic) + 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); } bzero(buf, bufsz); (void) sprintf(buf, fmt, nic); if (offline || (numifs == 0)) { /* Nothing else to do */ rcm_log_message(RCM_TRACE2, "IP: usage (%s) info = %s\n", node->ip_resource, buf); return (buf); } for (lif = node->ip_pif->pi_lifs; lif != NULL; lif = lif->li_next) { void *addr; int af; if (!(lif->li_ifflags & IFF_UP)) { /* ignore interfaces not up */ continue; } af = lif->li_addr.family; 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, INET6_ADDRSTRLEN) == NULL) { rcm_log_message(RCM_ERROR, _("IP: inet_ntop: %s\n"), strerror(errno)); continue; } rcm_log_message(RCM_DEBUG, "IP addr := %s\n", addrstr); (void) strcat(buf, addrstr); numifs--; if (numifs > 0) { (void) strcat(buf, ", "); } } rcm_log_message(RCM_TRACE2, "IP: usage (%s) info = %s\n", node->ip_resource, buf); return (buf); } /* * Cache management routines, all cache management functions should be * be called with cache_lock held. */ /* * cache_lookup() - Get a cache node for a resource. Supports VLAN interfaces. * 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; char *resource; /* physical resource */ 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); } if ((resource = get_physical_resource(rsrc)) == NULL) { errno = ENOENT; return (NULL); } probe = cache_head.ip_next; while (probe != &cache_tail) { if (probe->ip_resource && STREQ(resource, probe->ip_resource)) { rcm_log_message(RCM_TRACE2, "IP: cache lookup success(%s)\n", rsrc); free(resource); return (probe); } probe = probe->ip_next; } free(resource); 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) { /* 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) { 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 */ /*ARGSUSED*/ static int update_pif(rcm_handle_t *hd, int af, int sock, struct lifreq *lifr) { char ifname[RCM_NET_RESOURCE_MAX]; 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", lifr->lifr_name); if (!ifparse_ifspec(lifr->lifr_name, &ifspec)) { rcm_log_message(RCM_ERROR, _("IP: bad network interface: %s\n"), lifr->lifr_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 */ (void) strcpy(lifreq.lifr_name, lifr->lifr_name); if (ioctl(sock, SIOCGLIFFLAGS, (char *)&lifreq) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFFLAGS(%s): %s\n"), pif.pi_ifname, strerror(errno)); return (-1); } (void) memcpy(&ifflags, &lifreq.lifr_flags, sizeof (ifflags)); /* Ignore loopback and multipoint interfaces */ if (!(ifflags & IFF_MULTICAST) || (ifflags & IFF_LOOPBACK)) { rcm_log_message(RCM_TRACE3, "IP: if ignored (%s)\n", pif.pi_ifname); return (0); } /* Get the interface group name for this interface */ if (ioctl(sock, SIOCGLIFGROUPNAME, (char *)&lifreq) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFGROUPNAME(%s): %s\n"), lifreq.lifr_name, strerror(errno)); return (-1); } /* copy the group name */ (void) memcpy(&pif.pi_grpname, &lifreq.lifr_groupname, sizeof (pif.pi_grpname)); pif.pi_grpname[sizeof (pif.pi_grpname) - 1] = '\0'; /* Get the interface address for this interface */ if (ioctl(sock, SIOCGLIFADDR, (char *)&lifreq) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFADDR(%s): %s\n"), lifreq.lifr_name, strerror(errno)); return (-1); } (void) memcpy(&ifaddr, &lifreq.lifr_addr, sizeof (ifaddr)); /* Search for the interface in our cache */ (void) snprintf(ifname, sizeof (ifname), "%s/%s", RCM_NET_PREFIX, pif.pi_ifname); probe = cache_lookup(hd, ifname, CACHE_NO_REFRESH); if (probe != NULL) { probe->ip_cachestate &= ~(CACHE_IF_STALE); } else { if ((probe = calloc(1, sizeof (ip_cache_t))) == NULL) { /* malloc errors are bad */ rcm_log_message(RCM_ERROR, _("IP: calloc: %s\n"), strerror(errno)); return (-1); } probe->ip_resource = get_physical_resource(ifname); if (!probe->ip_resource) { rcm_log_message(RCM_ERROR, _("IP: strdup: %s\n"), strerror(errno)); free(probe); return (-1); } 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 pif properties */ (void) memcpy(&probepif->pi_grpname, &pif.pi_grpname, sizeof (pif.pi_grpname)); /* 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) { int sock; char *buf; struct lifnum lifn; struct lifconf lifc; struct lifreq *lifrp; int i; rcm_log_message(RCM_TRACE2, "IP: update_ipifs\n"); 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); } lifn.lifn_family = af; lifn.lifn_flags = 0; if (ioctl(sock, SIOCGLIFNUM, (char *)&lifn) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCLGIFNUM failed: %s\n"), strerror(errno)); (void) close(sock); return (-1); } if ((buf = calloc(lifn.lifn_count, sizeof (struct lifreq))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc: %s\n"), strerror(errno)); (void) close(sock); return (-1); } lifc.lifc_family = af; lifc.lifc_flags = 0; lifc.lifc_len = sizeof (struct lifreq) * lifn.lifn_count; lifc.lifc_buf = buf; if (ioctl(sock, SIOCGLIFCONF, (char *)&lifc) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFCONF failed: %s\n"), strerror(errno)); free(buf); (void) close(sock); return (-1); } /* now we need to search for active interfaces */ lifrp = lifc.lifc_req; for (i = 0; i < lifn.lifn_count; i++) { (void) update_pif(hd, af, sock, lifrp); lifrp++; } free(buf); (void) close(sock); 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 *nic = NULL; int len; const char *errfmt; char *error; if ((node != NULL) && (node->ip_pif != NULL) && (node->ip_pif->pi_ifname != NULL)) { nic = strrchr(node->ip_pif->pi_ifname, '/'); nic = nic ? nic + 1 : node->ip_pif->pi_ifname; } if (errorp != NULL) *errorp = NULL; if (nic == NULL) { rcm_log_message(RCM_ERROR, _("IP: %s\n"), errmsg); errfmt = _("IP: %s"); len = strlen(errfmt) + strlen(errmsg) + 1; if (error = (char *)calloc(1, len)) { (void) sprintf(error, errfmt, errmsg); } } else { rcm_log_message(RCM_ERROR, _("IP: %s(%s)\n"), errmsg, nic); errfmt = _("IP: %s(%s)"); len = strlen(errfmt) + strlen(errmsg) + strlen(nic) + 1; if (error = (char *)calloc(1, len)) { (void) sprintf(error, errfmt, errmsg, nic); } } 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)); (void) 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); (void) 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", USR_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", USR_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)); (void) 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); (void) clr_cfg_state(pif); return (-1); } (void) pclose(fp); lif->li_reconfig = malloc(strlen(buf)+1); if (lif->li_reconfig == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc error (%s) %s\n"), pif->pi_ifname, strerror(errno)); (void) clr_cfg_state(pif); return (-1); } (void) strcpy(lif->li_reconfig, buf); 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; int ipv4 = 0, ipv6 = 0; char syscmd[MAX_RECONFIG_SIZE + LIFNAMSIZ]; rcm_log_message(RCM_TRACE2, "IP: if_unplumb(%s)\n", node->ip_resource); pif = node->ip_pif; lif = pif->pi_lifs; while (lif != NULL) { if (lif->li_ifflags & IFF_IPV4) { ipv4++; } else if (lif->li_ifflags & IFF_IPV6) { ipv6++; } else { /* Unlikely case */ rcm_log_message(RCM_DEBUG, _("IP: Unplumb ignored (%s:%d)\n"), pif->pi_ifname, lif->li_ifnum); lif = lif->li_next; continue; } lif = lif->li_next; } /* Unplumb the physical interface */ if (ipv4) { rcm_log_message(RCM_TRACE2, "IP: if_unplumb: ifconfig %s unplumb\n", pif->pi_ifname); (void) snprintf(syscmd, sizeof (syscmd), "%s %s unplumb\n", USR_SBIN_IFCONFIG, pif->pi_ifname); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot unplumb (%s) %s\n"), pif->pi_ifname, strerror(errno)); return (-1); } } if (ipv6) { rcm_log_message(RCM_TRACE2, "IP: if_unplumb: ifconfig %s inet6 unplumb\n", pif->pi_ifname); (void) snprintf(syscmd, sizeof (syscmd), "%s %s inet6 unplumb\n", USR_SBIN_IFCONFIG, pif->pi_ifname); if (rcm_exec_cmd(syscmd) != 0) { 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; char syscmd[LIFNAMSIZ+MAXPATHLEN]; /* must be big enough */ int max_ipv4 = 0, max_ipv6 = 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; lif = pif->pi_lifs; /* * Make a first pass to plumb in physical interfaces and get a count * of the max logical interfaces */ while (lif != NULL) { if (lif->li_ifflags & IFF_IPV4) { if (lif->li_ifnum > max_ipv4) { max_ipv4 = lif->li_ifnum; } } else if (lif->li_ifflags & IFF_IPV6) { if (lif->li_ifnum > max_ipv6) { max_ipv6 = lif->li_ifnum; } } else { /* Unlikely case */ rcm_log_message(RCM_DEBUG, _("IP: Re-plumb ignored (%s:%d)\n"), pif->pi_ifname, lif->li_ifnum); lif = lif->li_next; continue; } if (lif->li_ifnum == 0) { /* physical interface instance */ if ((lif->li_ifflags & IFF_NOFAILOVER) || (strcmp(pif->pi_grpname, "") == 0)) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s\n", USR_SBIN_IFCONFIG, lif->li_reconfig); } else if (lif->li_ifflags & IFF_IPV4) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s inet plumb group %s\n", USR_SBIN_IFCONFIG, pif->pi_ifname, pif->pi_grpname); } else if (lif->li_ifflags & IFF_IPV6) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s inet6 plumb group %s\n", USR_SBIN_IFCONFIG, pif->pi_ifname, pif->pi_grpname); } rcm_log_message(RCM_TRACE2, "IP: if_replumb: %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot plumb (%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); } } } lif = lif->li_next; } /* Now, add all the logical interfaces in the correct order */ for (i = 1; i <= MAX(max_ipv6, max_ipv4); i++) { /* reset lif through every iteration */ lif = pif->pi_lifs; while (lif != NULL) { if (((lif->li_ifflags & IFF_NOFAILOVER) || (strcmp(pif->pi_grpname, "") == 0)) && (lif->li_ifnum == i)) { /* Plumb in the logical interface */ (void) snprintf(syscmd, sizeof (syscmd), "%s %s\n", USR_SBIN_IFCONFIG, lif->li_reconfig); rcm_log_message(RCM_TRACE2, "IP: if_replumb: %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot addif (%s:%d) " "%s\n"), pif->pi_ifname, i, strerror(errno)); return (-1); } } lif = lif->li_next; } } 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; } } /* * ip_ipmp_offline() - Failover from if_from to if_to using a * minimum redudancy of min_red. This uses IPMPs * "offline" mechanism to achieve the failover. */ static int ip_ipmp_offline(ip_cache_t *if_from, ip_cache_t *if_to) { mpathd_cmd_t mpdcmd; if ((if_from == NULL) || (if_from->ip_pif == NULL) || (if_from->ip_pif->pi_ifname == NULL)) { return (-1); } rcm_log_message(RCM_TRACE1, "IP: ip_ipmp_offline\n"); mpdcmd.cmd_command = MI_OFFLINE; (void) strcpy(mpdcmd.cmd_ifname, if_from->ip_pif->pi_ifname); if ((if_to != NULL) && (if_to->ip_pif != NULL) && (if_to->ip_pif->pi_ifname != NULL)) { rcm_log_message(RCM_TRACE1, "IP: ip_ipmp_offline (%s)->(%s)\n", if_from->ip_pif->pi_ifname, if_to->ip_pif->pi_ifname); (void) strncpy(mpdcmd.cmd_movetoif, if_to->ip_pif->pi_ifname, sizeof (mpdcmd.cmd_movetoif)); mpdcmd.cmd_movetoif[sizeof (mpdcmd.cmd_movetoif) - 1] = '\0'; } else { rcm_log_message(RCM_TRACE1, "IP: ip_ipmp_offline (%s)->(any)\n", if_from->ip_pif->pi_ifname); (void) strcpy(mpdcmd.cmd_movetoif, ""); /* signifies any */ } mpdcmd.cmd_min_red = if_from->ip_ifred; if (mpathd_send_cmd(&mpdcmd) < 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd offline error: %s\n"), strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE1, "IP: ipmp offline success\n"); return (0); } /* * ip_ipmp_undo_offline() - Undo prior offline of the interface. * This uses IPMPs "undo offline" feature. */ static int ip_ipmp_undo_offline(ip_cache_t *node) { mpathd_cmd_t mpdcmd; mpdcmd.cmd_command = MI_UNDO_OFFLINE; (void) strcpy(mpdcmd.cmd_ifname, node->ip_pif->pi_ifname); if (mpathd_send_cmd(&mpdcmd) < 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd error: %s\n"), strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE1, "IP: ipmp undo offline success\n"); return (0); } /* * get_physical_resource() - Convert a name (e.g., "SUNW_network/hme0:1" or * "SUNW_network/hme1000") into a dynamically allocated string containing the * associated physical device resource name ("SUNW_network/hme0"). Since we * assume that interface names map directly to device names, this is a * pass-through operation, with the exception that logical interface numbers * and VLANs encoded in the PPA are stripped. This logic will need to be * revisited to support administratively-chosen interface names. */ static char * get_physical_resource(const char *rsrc) { char *rsrc_ifname, *ifname; ifspec_t ifspec; rsrc_ifname = strchr(rsrc, '/'); if (rsrc_ifname == NULL || !ifparse_ifspec(rsrc_ifname + 1, &ifspec)) { rcm_log_message(RCM_ERROR, _("IP: bad resource: %s\n"), rsrc); return (NULL); } ifname = malloc(RCM_NET_RESOURCE_MAX); if (ifname == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc error(%s): %s\n"), strerror(errno), rsrc); return (NULL); } (void) snprintf(ifname, RCM_NET_RESOURCE_MAX, "%s/%s%d", RCM_NET_PREFIX, ifspec.ifsp_devnm, VLAN_GET_PPA(ifspec.ifsp_ppa)); return (ifname); } /* * if_get_flags() - Return the cached physical interface flags * Call with cache_lock held */ static uint64_t if_get_flags(ip_pif_t *pif) { ip_lif_t *lif; for (lif = pif->pi_lifs; lif != NULL; lif = lif->li_next) { if (lif->li_ifnum == 0) { return (lif->li_ifflags & RCM_PIF_FLAGS); } } return (0); } /* * mpathd_send_cmd() - Sends the command to in.mpathd. */ static int mpathd_send_cmd(mpathd_cmd_t *mpd) { mpathd_unoffline_t mpc; struct mpathd_response mpr; int i; int s; rcm_log_message(RCM_TRACE1, "IP: mpathd_send_cmd \n"); for (i = 0; i < MPATHD_MAX_RETRIES; i++) { s = connect_to_mpathd(AF_INET); if (s == -1) { s = connect_to_mpathd(AF_INET6); if (s == -1) { rcm_log_message(RCM_ERROR, _("IP: Cannot talk to mpathd\n")); return (-1); } } switch (mpd->cmd_command) { case MI_OFFLINE : rcm_log_message(RCM_TRACE1, "IP: MI_OFFLINE: " "(%s)->(%s) redundancy = %d\n", mpd->cmd_ifname, mpd->cmd_movetoif, mpd->cmd_min_red); if (write(s, mpd, sizeof (mpathd_cmd_t)) != sizeof (mpathd_cmd_t)) { rcm_log_message(RCM_ERROR, _("IP: mpathd write: %s\n"), strerror(errno)); (void) close(s); return (-1); } break; case MI_SETOINDEX : rcm_log_message(RCM_TRACE1, "IP: MI_SETOINDEX: " "(%s)->(%s) family = %d\n", mpd->from_lifname, mpd->to_pifname, mpd->addr_family); if (write(s, mpd, sizeof (mpathd_cmd_t)) != sizeof (mpathd_cmd_t)) { rcm_log_message(RCM_ERROR, _("IP: mpathd write: %s\n"), strerror(errno)); (void) close(s); return (-1); } break; case MI_UNDO_OFFLINE: /* mpathd checks for exact size of the message */ mpc.cmd_command = mpd->cmd_command; (void) strcpy(mpc.cmd_ifname, mpd->cmd_ifname); rcm_log_message(RCM_TRACE1, "IP: MI_UNDO_OFFLINE: " "(%s)\n", mpd->cmd_ifname); if (write(s, &mpc, sizeof (mpathd_unoffline_t)) != sizeof (mpathd_unoffline_t)) { rcm_log_message(RCM_ERROR, _("IP: mpathd write: %s\n"), strerror(errno)); (void) close(s); return (-1); } break; default : rcm_log_message(RCM_ERROR, _("IP: unsupported mpathd command\n")); (void) close(s); return (-1); } bzero(&mpr, sizeof (struct mpathd_response)); /* Read the result from mpathd */ if (read(s, &mpr, sizeof (struct mpathd_response)) != sizeof (struct mpathd_response)) { rcm_log_message(RCM_ERROR, _("IP: mpathd read : %s\n"), strerror(errno)); (void) close(s); return (-1); } (void) close(s); if (mpr.resp_mpathd_err == 0) { rcm_log_message(RCM_TRACE1, "IP: mpathd_send_cmd success\n"); return (0); /* Successful */ } if (mpr.resp_mpathd_err == MPATHD_SYS_ERROR) { if (mpr.resp_sys_errno == EAGAIN) { (void) sleep(1); rcm_log_message(RCM_DEBUG, _("IP: mpathd retrying\n")); continue; /* Retry */ } errno = mpr.resp_sys_errno; rcm_log_message(RCM_WARNING, _("IP: mpathd_send_cmd error: %s\n"), strerror(errno)); } else if (mpr.resp_mpathd_err == MPATHD_MIN_RED_ERROR) { errno = EIO; rcm_log_message(RCM_ERROR, _("IP: in.mpathd(1M): " "Minimum redundancy not met\n")); } else { rcm_log_message(RCM_ERROR, _("IP: mpathd_send_cmd error\n")); } /* retry */ } rcm_log_message(RCM_ERROR, _("IP: mpathd_send_cmd failed %d retries\n"), MPATHD_MAX_RETRIES); return (-1); } /* * Returns -1 on failure. Returns the socket file descriptor on * success. */ static int connect_to_mpathd(int family) { int s; struct sockaddr_storage ss; struct sockaddr_in *sin = (struct sockaddr_in *)&ss; struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&ss; struct in6_addr loopback_addr = IN6ADDR_LOOPBACK_INIT; int addrlen; int ret; int on; rcm_log_message(RCM_TRACE1, "IP: connect_to_mpathd\n"); s = socket(family, SOCK_STREAM, 0); if (s < 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd socket: %s\n"), strerror(errno)); return (-1); } bzero((char *)&ss, sizeof (ss)); ss.ss_family = family; /* * Need to bind to a privelged port. For non-root, this * will fail. in.mpathd verifies that only commands coming * from priveleged ports succeed so that the ordinary user * can't issue offline commands. */ on = 1; if (setsockopt(s, IPPROTO_TCP, TCP_ANONPRIVBIND, &on, sizeof (on)) < 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd setsockopt: TCP_ANONPRIVBIND: %s\n"), strerror(errno)); return (-1); } switch (family) { case AF_INET: sin->sin_port = 0; sin->sin_addr.s_addr = htonl(INADDR_LOOPBACK); addrlen = sizeof (struct sockaddr_in); break; case AF_INET6: sin6->sin6_port = 0; sin6->sin6_addr = loopback_addr; addrlen = sizeof (struct sockaddr_in6); break; } ret = bind(s, (struct sockaddr *)&ss, addrlen); if (ret != 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd bind: %s\n"), strerror(errno)); return (-1); } switch (family) { case AF_INET: sin->sin_port = htons(MPATHD_PORT); break; case AF_INET6: sin6->sin6_port = htons(MPATHD_PORT); break; } ret = connect(s, (struct sockaddr *)&ss, addrlen); if (ret != 0) { if (errno == ECONNREFUSED) { /* in.mpathd is not running, start it */ if (rcm_exec_cmd(MPATHD_PATH) == -1) { rcm_log_message(RCM_ERROR, _("IP: mpathd exec: %s\n"), strerror(errno)); return (-1); } ret = connect(s, (struct sockaddr *)&ss, addrlen); } if (ret != 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd connect: %s\n"), strerror(errno)); return (-1); } } on = 0; if (setsockopt(s, IPPROTO_TCP, TCP_ANONPRIVBIND, &on, sizeof (on)) < 0) { rcm_log_message(RCM_ERROR, _("IP: mpathd setsockopt TCP_ANONPRIVBIND: %s\n"), strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE1, "IP: connect_to_mpathd success\n"); return (s); } /* * 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", USR_SBIN_IFCONFIG, name, arg, pos); } else if (op == MOD_INSERT) { (void) snprintf(syscmd, sizeof (syscmd), "%s %s modinsert %s@%d\n", USR_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; rcm_log_message(RCM_TRACE1, "IP: getmodlist(%s)\n", name); (void) strncpy(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)); (void) ip_plink(mux_fd, muxid_fd, fd, &lifr); return (-1); } 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)); (void) ip_plink(mux_fd, muxid_fd, fd, &lifr); return (-1); } 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)); (void) ip_plink(mux_fd, muxid_fd, fd, &lifr); return (-1); } for (i = 0; i < strlist.sl_nmods; i++) { lif->li_modules[i] = malloc(strlen(strlist.sl_modlist[i].l_name)+1); if (lif->li_modules[i] == NULL) { rcm_log_message(RCM_ERROR, _("IP: get_modlist(%s): %s\n"), name, strerror(errno)); (void) ip_plink(mux_fd, muxid_fd, fd, &lifr); return (-1); } (void) strcpy(lif->li_modules[i], strlist.sl_modlist[i].l_name); } 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)); } /* * 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. */ 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. */ 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() - Compile list of IP addresses hosted on this NIC (node) * This routine malloc() required memeory for the list * Returns list on success, NULL if failed * Call with cache_lock held. */ static char ** ip_get_addrlist(ip_cache_t *node) { ip_lif_t *lif; char **addrlist = NULL; int numifs; char addrstr[INET6_ADDRSTRLEN]; void *addr; int af; int i; 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++) { af = lif->li_addr.family; 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, INET6_ADDRSTRLEN) == NULL) { rcm_log_message(RCM_ERROR, _("IP: inet_ntop: %s\n"), strerror(errno)); ip_free_addrlist(addrlist); return (NULL); } if ((addrlist[i] = malloc(strlen(addrstr) + RCM_SIZE_SUNW_IP)) == 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) strcpy(addrlist[i], RCM_STR_SUNW_IP); /* SUNW_ip/ */ (void) strcat(addrlist[i], addrstr); /* SUNW_ip/
*/ 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, char *ifinst, char **errorp, uint_t flags, rcm_info_t **depend_info) { char ifname[LIFNAMSIZ + 1]; char cached_name[RCM_NET_RESOURCE_MAX]; ip_cache_t *node; char *cp; rcm_log_message(RCM_TRACE1, "IP: ip_consumer_notify(%s)\n", ifinst); if (ifinst == NULL) return; (void) memcpy(&ifname, ifinst, sizeof (ifname)); ifname[sizeof (ifname) - 1] = '\0'; /* remove LIF component */ cp = strchr(ifname, ':'); if (cp) { *cp = 0; } /* Check for the interface in the cache */ (void) snprintf(cached_name, sizeof (cached_name), "%s/%s", RCM_NET_PREFIX, ifname); (void) mutex_lock(&cache_lock); if ((node = cache_lookup(hd, cached_name, CACHE_REFRESH)) == NULL) { rcm_log_message(RCM_TRACE1, "IP: Skipping interface(%s) \n", ifname); (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"); return; } /* * process_nvlist() - Determine network interfaces on a new attach by * processing the nvlist */ /*ARGSUSED*/ static int process_nvlist(nvlist_t *nvl) { nvpair_t *nvp = NULL; char *driver_name; char *devfs_path; int32_t instance; char *minor_byte_array; /* packed nvlist of minor_data */ uint_t nminor; /* # of minor nodes */ struct devfs_minor_data *mdata; nvlist_t *mnvl; nvpair_t *mnvp = NULL; rcm_log_message(RCM_TRACE1, "IP: process_nvlist\n"); while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { /* Get driver name */ if (STREQ(nvpair_name(nvp), RCM_NV_DRIVER_NAME)) { if (nvpair_value_string(nvp, &driver_name) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get driver name\n")); return (-1); } } /* Get instance */ if (STREQ(nvpair_name(nvp), RCM_NV_INSTANCE)) { if (nvpair_value_int32(nvp, &instance) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get device instance\n")); return (-1); } } /* Get devfs_path */ if (STREQ(nvpair_name(nvp), RCM_NV_DEVFS_PATH)) { if (nvpair_value_string(nvp, &devfs_path) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get device path\n")); return (-1); } } /* Get minor data */ if (STREQ(nvpair_name(nvp), RCM_NV_MINOR_DATA)) { if (nvpair_value_byte_array(nvp, (uchar_t **)&minor_byte_array, &nminor) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get device minor data\n")); return (-1); } if (nvlist_unpack(minor_byte_array, nminor, &mnvl, 0) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get minor node data\n")); return (-1); } mdata = (struct devfs_minor_data *)calloc(1, sizeof (struct devfs_minor_data)); if (mdata == NULL) { rcm_log_message(RCM_WARNING, _("IP: calloc error(%s)\n"), strerror(errno)); nvlist_free(mnvl); return (-1); } /* Enumerate minor node data */ while ((mnvp = nvlist_next_nvpair(mnvl, mnvp)) != NULL) { /* Get minor type */ if (STREQ(nvpair_name(mnvp), RCM_NV_MINOR_TYPE)) { if (nvpair_value_int32(mnvp, &mdata->minor_type) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get minor " "type \n")); nvlist_free(mnvl); return (-1); } } /* Get minor name */ if (STREQ(nvpair_name(mnvp), RCM_NV_MINOR_NAME)) { if (nvpair_value_string(mnvp, &mdata->minor_name) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get minor " "name \n")); nvlist_free(mnvl); return (-1); } } /* Get minor node type */ if (STREQ(nvpair_name(mnvp), RCM_NV_MINOR_NODE_TYPE)) { if (nvpair_value_string(mnvp, &mdata->minor_node_type) != 0) { rcm_log_message(RCM_WARNING, _("IP: cannot get minor " "node type \n")); nvlist_free(mnvl); return (-1); } } } (void) process_minor(devfs_path, driver_name, instance, mdata); nvlist_free(mnvl); } } rcm_log_message(RCM_TRACE1, "IP: process_nvlist success\n"); return (0); } static void process_minor(char *devfs_path, char *name, int instance, struct devfs_minor_data *mdata) { struct net_interface *nip; struct ni_list *nilp; struct ni_list *p; struct ni_list **pp; char *cname; size_t cnamelen; rcm_log_message(RCM_TRACE1, "IP: process_minor\n"); if ((mdata->minor_node_type != NULL) && !STREQ(mdata->minor_node_type, PROP_NV_DDI_NETWORK)) { /* Process network devices only */ return; } rcm_log_message(RCM_TRACE1, "IP: Examining %s (%s)\n", devfs_path, mdata->minor_name); /* Sanity check, instances > 999 are illegal */ if (instance > 999) { errno = EINVAL; rcm_log_message(RCM_ERROR, _("IP: invalid instance %d(%s)\n"), instance, strerror(errno)); return; } /* Now, let's add the node to the interface list */ if ((nip = malloc(sizeof (struct net_interface))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc failure(%s)\n"), strerror(errno)); return; } (void) memset(nip, 0, sizeof (struct net_interface)); cnamelen = strlen(name) + 1; /* Set NIC type */ if ((nip->type = (char *)malloc(cnamelen)) == NULL) { free(nip); rcm_log_message(RCM_ERROR, _("IP: malloc failure(%s)\n"), strerror(errno)); return; } (void) memcpy(nip->type, name, cnamelen); cnamelen += 3; if ((cname = (char *)malloc(cnamelen)) == NULL) { free(nip->type); free(nip); rcm_log_message(RCM_ERROR, _("IP: malloc failure(%s)\n"), strerror(errno)); return; } (void) snprintf(cname, cnamelen, "%s%d", name, instance); rcm_log_message(RCM_TRACE1, "IP: Found SUNW_network/%s%d\n", name, instance); /* Set NIC name */ if ((nip->name = strdup(cname)) == NULL) { free(nip->type); free(nip); free(cname); rcm_log_message(RCM_ERROR, _("IP: strdup failure(%s)\n"), strerror(errno)); return; } free(cname); /* Add new interface to the list */ (void) mutex_lock(&nil_lock); for (pp = &nil_head; (p = *pp) != NULL; pp = &(p->next)) { cname = p->nifp->name; if (strcmp(cname, nip->name) == 0) break; } if (p != NULL) { (void) mutex_unlock(&nil_lock); free(nip->name); free(nip->type); free(nip); rcm_log_message(RCM_TRACE1, "IP: secondary node - ignoring\n"); return; } if ((nilp = malloc(sizeof (struct ni_list))) == NULL) { (void) mutex_unlock(&nil_lock); free(nip->name); free(nip->type); free(nip); rcm_log_message(RCM_ERROR, _("IP: malloc failure(%s)\n"), strerror(errno)); return; } nilp->nifp = nip; nilp->next = NULL; *pp = nilp; num_ni++; /* Increment interface count */ (void) mutex_unlock(&nil_lock); rcm_log_message(RCM_TRACE1, "IP: added new node\n"); } /* * if_configure() - Configure a physical interface after attach */ static int if_configure(char *ifinst) { char cfgfile[MAXPATHLEN]; char ifname[LIFNAMSIZ + 1]; char cached_name[RCM_NET_RESOURCE_MAX]; struct stat statbuf; ip_cache_t *node; char *cp; int af = 0; int ipmp = 0; if (ifinst == NULL) return (0); rcm_log_message(RCM_TRACE1, "IP: if_configure(%s)\n", ifinst); /* * Check if the interface is already configured */ (void) memcpy(&ifname, ifinst, sizeof (ifname)); ifname[sizeof (ifname) - 1] = '\0'; /* remove LIF component */ cp = strchr(ifname, ':'); if (cp) { *cp = 0; } /* Check for the interface in the cache */ (void) snprintf(cached_name, sizeof (cached_name), "%s/%s", RCM_NET_PREFIX, ifname); /* Check if the interface is new or was 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(%s) \n", ifname); (void) mutex_unlock(&cache_lock); return (0); } (void) mutex_unlock(&cache_lock); /* Scan IPv4 configuration first */ (void) snprintf(cfgfile, MAXPATHLEN, "%s%s", CFGFILE_FMT_IPV4, ifinst); cfgfile[MAXPATHLEN - 1] = '\0'; rcm_log_message(RCM_TRACE1, "IP: Scanning %s\n", cfgfile); if (stat(cfgfile, &statbuf) == 0) { af |= CONFIG_AF_INET; if (isgrouped(cfgfile)) { ipmp++; } } /* Scan IPv6 configuration details */ (void) snprintf(cfgfile, MAXPATHLEN, "%s%s", CFGFILE_FMT_IPV6, ifinst); cfgfile[MAXPATHLEN - 1] = '\0'; rcm_log_message(RCM_TRACE1, "IP: Scanning %s\n", cfgfile); if (stat(cfgfile, &statbuf) == 0) { af |= CONFIG_AF_INET6; if ((ipmp == 0) && isgrouped(cfgfile)) { ipmp++; } } if (af & CONFIG_AF_INET) { if (if_ipmp_config(ifinst, CONFIG_AF_INET, ipmp) == -1) { rcm_log_message(RCM_ERROR, _("IP: IPv4 Post-attach failed (%s)\n"), ifinst); return (-1); } } if (af & CONFIG_AF_INET6) { if (if_ipmp_config(ifinst, CONFIG_AF_INET6, ipmp) == -1) { rcm_log_message(RCM_ERROR, _("IP: IPv6 Post-attach failed(%s)\n"), ifinst); return (-1); } } rcm_log_message(RCM_TRACE1, "IP: if_configure(%s) success\n", ifinst); return (0); } /* * isgrouped() - Scans the given config file to see if this is a grouped * interface * Returns non-zero if true; 0 if false */ static int isgrouped(char *cfgfile) { FILE *fp; struct stat statb; char *buf = NULL; char *tokens[MAXARGS]; /* token pointers */ char tspace[MAXLINE]; /* token space */ int ntok; int group = 0; if (cfgfile == NULL) return (0); 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 (0); } /* * 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 (0); } if ((fp = fopen(cfgfile, "r")) == NULL) { rcm_log_message(RCM_ERROR, _("IP: Cannot open configuration file(%s): %s\n"), cfgfile, strerror(errno)); return (0); } if ((buf = calloc(1, statb.st_size)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc failure(%s): %s\n"), cfgfile, strerror(errno)); (void) fclose(fp); return (0); } while (fgets(buf, statb.st_size, fp) != NULL) { if (*buf == '\0') continue; tokenize(buf, tokens, tspace, &ntok); while (ntok) { if (STREQ("group", tokens[ntok - 1])) { if (tokens[ntok] != NULL) { group++; } } ntok--; } } free(buf); (void) fclose(fp); if (group <= 0) { rcm_log_message(RCM_TRACE1, "IP: isgrouped(%s) non-grouped\n", cfgfile); return (0); } else { rcm_log_message(RCM_TRACE1, "IP: isgrouped(%s) grouped\n", cfgfile); return (1); } } /* * if_ipmp_config() - Configure an interface instance as specified by the * address family af and if it is grouped (ipmp). */ static int if_ipmp_config(char *ifinst, int af, int ipmp) { char cfgfile[MAXPATHLEN]; /* configuration file */ FILE *fp; struct stat statb; char *buf; char *tokens[MAXARGS]; /* list of config attributes */ char tspace[MAXLINE]; /* token space */ char syscmd[MAX_RECONFIG_SIZE + MAXPATHLEN + 1]; char grpcmd[MAX_RECONFIG_SIZE + MAXPATHLEN + 1]; char fstr[8]; /* address family string inet or inet6 */ int nofailover = 0; int newattach = 0; int cmdvalid = 0; int ntok; int n; int stdif = 0; if (ifinst == NULL) return (0); rcm_log_message(RCM_TRACE1, "IP: if_ipmp_config(%s) ipmp = %d\n", ifinst, ipmp); if (af & CONFIG_AF_INET) { (void) snprintf(cfgfile, MAXPATHLEN, "%s%s", CFGFILE_FMT_IPV4, ifinst); (void) strcpy(fstr, "inet"); } else if (af & CONFIG_AF_INET6) { (void) snprintf(cfgfile, MAXPATHLEN, "%s%s", CFGFILE_FMT_IPV6, ifinst); (void) strcpy(fstr, "inet6"); } else { return (0); /* nothing to do */ } cfgfile[MAXPATHLEN - 1] = '\0'; grpcmd[0] = '\0'; if (stat(cfgfile, &statb) != 0) { rcm_log_message(RCM_TRACE1, _("IP: No config file(%s)\n"), ifinst); return (0); } /* Config file exists, plumb in the physical interface */ if (af & CONFIG_AF_INET6) { if (if_getcount(AF_INET6) == 0) { /* * Configure software loopback driver if this is the * first IPv6 interface plumbed */ newattach++; (void) snprintf(syscmd, sizeof (syscmd), "%s lo0 %s plumb ::1 up", USR_SBIN_IFCONFIG, fstr); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot plumb (%s) %s\n"), ifinst, strerror(errno)); return (-1); } } (void) snprintf(syscmd, sizeof (syscmd), "%s %s %s plumb up", USR_SBIN_IFCONFIG, ifinst, fstr); } else { (void) snprintf(syscmd, sizeof (syscmd), "%s %s %s plumb ", USR_SBIN_IFCONFIG, ifinst, fstr); if (if_getcount(AF_INET) == 0) { newattach++; } } rcm_log_message(RCM_TRACE1, "IP: Exec: %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Cannot plumb (%s) %s\n"), ifinst, strerror(errno)); return (-1); } /* Check if config file is empty, if so, nothing else to do */ if (statb.st_size == 0) { rcm_log_message(RCM_TRACE1, _("IP: Zero size config file(%s)\n"), ifinst); return (0); } if ((fp = fopen(cfgfile, "r")) == NULL) { rcm_log_message(RCM_ERROR, _("IP: Open error(%s): %s\n"), cfgfile, strerror(errno)); return (-1); } if ((buf = calloc(1, statb.st_size)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc(%s): %s\n"), ifinst, strerror(errno)); (void) fclose(fp); return (-1); } /* a single line with one token implies a classical if */ if (fgets(buf, statb.st_size, fp) != NULL) { tokenize(buf, tokens, tspace, &ntok); if (ntok == 1) { rcm_log_message(RCM_TRACE1, "IP: Standard interface\n"); stdif++; } } if (fseek(fp, 0L, SEEK_SET) == -1) { rcm_log_message(RCM_ERROR, _("IP: fseek: %s\n"), strerror(errno)); return (-1); } /* * Process the config command * This loop also handles multiple logical interfaces that may * be configured on a single line */ while (fgets(buf, statb.st_size, fp) != NULL) { nofailover = 0; cmdvalid = 0; if (*buf == '\0') continue; tokenize(buf, tokens, tspace, &ntok); if (ntok <= 0) continue; /* Reset the config command */ (void) snprintf(syscmd, sizeof (syscmd), "%s %s %s ", USR_SBIN_IFCONFIG, ifinst, fstr); /* No parsing if this is first interface of its kind */ if (newattach) { (void) strcat(syscmd, buf); /* Classic if */ if ((af & CONFIG_AF_INET) && (stdif == 1)) { (void) strcat(syscmd, CFG_CMDS_STD); } rcm_log_message(RCM_TRACE1, "IP: New: %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: Error: %s (%s): %s\n"), syscmd, ifinst, strerror(errno)); } continue; } /* Parse the tokens to determine nature of the interface */ for (n = 0; n < ntok; n++) { /* Handle pathological failover cases */ if (STREQ("-failover", tokens[n])) nofailover++; if (STREQ("failover", tokens[n])) nofailover--; /* group attribute requires special processing */ if (STREQ("group", tokens[n])) { if (tokens[n + 1] != NULL) { (void) snprintf(grpcmd, sizeof (grpcmd), "%s %s %s %s %s", USR_SBIN_IFCONFIG, ifinst, fstr, tokens[n], tokens[n + 1]); n++; /* skip next token */ continue; } } /* Execute buffered command ? */ if (STREQ("set", tokens[n]) || STREQ("addif", tokens[n]) || STREQ("removeif", tokens[n]) || (n == (ntok -1))) { /* config command complete ? */ if (n == (ntok -1)) { ADDSPACE(syscmd); (void) strcat(syscmd, tokens[n]); cmdvalid++; } if (!cmdvalid) { ADDSPACE(syscmd); (void) strcat(syscmd, tokens[n]); cmdvalid++; continue; } /* Classic if ? */ if ((af & CONFIG_AF_INET) && (stdif == 1)) { (void) strcat(syscmd, CFG_CMDS_STD); } if (nofailover > 0) { rcm_log_message(RCM_TRACE1, "IP: Interim exec: %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: %s fail(%s): %s\n"), syscmd, ifinst, strerror(errno)); } } else { /* Have mpathd configure the address */ if (if_mpathd_configure(syscmd, ifinst, af, ipmp) != 0) { rcm_log_message(RCM_ERROR, _("IP: %s fail(%s): %s\n"), syscmd, ifinst, strerror(errno)); } } /* Reset config command */ (void) snprintf(syscmd, sizeof (syscmd), "%s %s %s ", USR_SBIN_IFCONFIG, ifinst, fstr); nofailover = 0; cmdvalid = 0; } /* * Note: No explicit command validation is required * since ifconfig to does it for us */ ADDSPACE(syscmd); (void) strcat(syscmd, tokens[n]); cmdvalid++; } } free(buf); (void) fclose(fp); /* * The group name needs to be set after all the test/nofailover * addresses have been configured. Otherwise, if IPMP detects that the * interface is failed, the addresses will be moved to a working * interface before the '-failover' flag can be set. */ if (grpcmd[0] != '\0') { rcm_log_message(RCM_TRACE1, "IP: set group name: %s\n", grpcmd); if (rcm_exec_cmd(grpcmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: %s fail(%s): %s\n"), grpcmd, ifinst, strerror(errno)); } } rcm_log_message(RCM_TRACE1, "IP: if_ipmp_config(%s) success\n", ifinst); return (0); } /* * if_mpathd_configure() - Determine configuration disposition of the interface */ static int if_mpathd_configure(char *syscmd, char *ifinst, int af, int ipmp) { char *tokens[MAXARGS]; char tspace[MAXLINE]; int ntok; char *addr; char *from_lifname; mpathd_cmd_t mpdcmd; int n; rcm_log_message(RCM_TRACE1, "IP: if_mpathd_configure(%s): %s\n", ifinst, syscmd); tokenize(syscmd, tokens, tspace, &ntok); if (ntok <= 0) return (0); addr = tokens[3]; /* by default, third token is valid address */ for (n = 0; n < ntok; n++) { if (STREQ("set", tokens[n]) || STREQ("addif", tokens[n])) { addr = tokens[n+1]; if (addr == NULL) { /* invalid format */ return (-1); } else break; } } /* Check std. commands or no failed over address */ if (STREQ("removeif", addr) || STREQ("group", addr) || ((from_lifname = get_mpathd_dest(addr, af)) == NULL)) { rcm_log_message(RCM_TRACE1, "IP: No failed-over host, exec %s\n", syscmd); if (rcm_exec_cmd(syscmd) != 0) { rcm_log_message(RCM_ERROR, _("IP: %s failed(%s): %s\n"), syscmd, ifinst, strerror(errno)); return (-1); } return (0); } /* Check for non-IPMP failover scenarios */ if ((ipmp <= 0) && (from_lifname != NULL)) { /* Address already hosted on another NIC, return */ rcm_log_message(RCM_TRACE1, "IP: Non-IPMP failed-over host(%s): %s\n", ifinst, addr); return (0); } /* * Valid failed-over host; have mpathd set the original index */ mpdcmd.cmd_command = MI_SETOINDEX; (void) strcpy(mpdcmd.from_lifname, from_lifname); (void) strcpy(mpdcmd.to_pifname, ifinst); if (af & CONFIG_AF_INET6) { mpdcmd.addr_family = AF_INET6; } else { mpdcmd.addr_family = AF_INET; } /* Send command to in.mpathd(1M) */ rcm_log_message(RCM_TRACE1, "IP: Attempting setoindex from (%s) to (%s) ....\n", from_lifname, ifinst); if (mpathd_send_cmd(&mpdcmd) < 0) { rcm_log_message(RCM_TRACE1, _("IP: mpathd set original index unsuccessful: %s\n"), strerror(errno)); return (-1); } rcm_log_message(RCM_TRACE1, "IP: setoindex success (%s) to (%s)\n", from_lifname, ifinst); return (0); } /* * get_mpathd_addr() - Return current destination for lif; caller is * responsible to free memory allocated for address */ static char * get_mpathd_dest(char *addr, int family) { int sock; char *buf; struct lifnum lifn; struct lifconf lifc; struct lifreq *lifrp; sa_family_t af = AF_INET; /* IPv4 by default */ int i; struct lifreq lifreq; struct sockaddr_in *sin; struct sockaddr_in6 *sin6; struct hostent *hp; char *ifname = NULL; char *prefix = NULL; char addrstr[INET6_ADDRSTRLEN]; char ifaddr[INET6_ADDRSTRLEN]; int err; if (addr == NULL) { return (NULL); } rcm_log_message(RCM_TRACE2, "IP: get_mpathd_dest(%s)\n", addr); if (family & CONFIG_AF_INET6) { af = AF_INET6; } else { af = AF_INET; } 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 (NULL); } lifn.lifn_family = af; lifn.lifn_flags = 0; if (ioctl(sock, SIOCGLIFNUM, (char *)&lifn) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCLGIFNUM failed: %s\n"), strerror(errno)); (void) close(sock); return (NULL); } if ((buf = calloc(lifn.lifn_count, sizeof (struct lifreq))) == NULL) { rcm_log_message(RCM_ERROR, _("IP: calloc: %s\n"), strerror(errno)); (void) close(sock); return (NULL); } lifc.lifc_family = af; lifc.lifc_flags = 0; lifc.lifc_len = sizeof (struct lifreq) * lifn.lifn_count; lifc.lifc_buf = buf; if (ioctl(sock, SIOCGLIFCONF, (char *)&lifc) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFCONF failed: %s\n"), strerror(errno)); free(buf); (void) close(sock); return (NULL); } /* Filter out prefix address from netmask */ (void) strcpy(ifaddr, addr); if ((prefix = strchr(ifaddr, '/')) != NULL) { *prefix = '\0'; /* We care about the address part only */ } /* Check for aliases */ hp = getipnodebyname(ifaddr, af, AI_DEFAULT, &err); if (hp) { if (inet_ntop(af, (void *)hp->h_addr_list[0], ifaddr, sizeof (ifaddr)) == NULL) { /* Restore original address and use it */ (void) strcpy(ifaddr, addr); if ((prefix = strchr(ifaddr, '/')) != NULL) { *prefix = '\0'; } } freehostent(hp); } rcm_log_message(RCM_TRACE2, "IP: ifaddr(%s) = %s\n", addr, ifaddr); /* now search the interfaces */ lifrp = lifc.lifc_req; for (i = 0; i < lifn.lifn_count; i++, lifrp++) { (void) strcpy(lifreq.lifr_name, lifrp->lifr_name); /* Get the interface address for this interface */ if (ioctl(sock, SIOCGLIFADDR, (char *)&lifreq) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCGLIFADDR: %s\n"), strerror(errno)); free(buf); (void) close(sock); return (NULL); } if (af == AF_INET6) { sin6 = (struct sockaddr_in6 *)&lifreq.lifr_addr; if (inet_ntop(AF_INET6, (void *)&sin6->sin6_addr, addrstr, sizeof (addrstr)) == NULL) { continue; } } else { sin = (struct sockaddr_in *)&lifreq.lifr_addr; if (inet_ntop(AF_INET, (void *)&sin->sin_addr, addrstr, sizeof (addrstr)) == NULL) { continue; } } if (STREQ(addrstr, ifaddr)) { /* Allocate memory to hold interface name */ if ((ifname = (char *)malloc(LIFNAMSIZ)) == NULL) { rcm_log_message(RCM_ERROR, _("IP: malloc: %s\n"), strerror(errno)); free(buf); (void) close(sock); return (NULL); } /* Copy the interface name */ /* * (void) memcpy(ifname, lifrp->lifr_name, * sizeof (ifname)); * ifname[sizeof (ifname) - 1] = '\0'; */ (void) strcpy(ifname, lifrp->lifr_name); break; } } (void) close(sock); free(buf); if (ifname == NULL) rcm_log_message(RCM_TRACE2, "IP: get_mpathd_dest(%s): none\n", addr); else rcm_log_message(RCM_TRACE2, "IP: get_mpathd_dest(%s): %s\n", addr, ifname); return (ifname); } static int if_getcount(int af) { int sock; struct lifnum lifn; rcm_log_message(RCM_TRACE1, "IP: if_getcount\n"); 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); } lifn.lifn_family = af; lifn.lifn_flags = 0; if (ioctl(sock, SIOCGLIFNUM, (char *)&lifn) < 0) { rcm_log_message(RCM_ERROR, _("IP: SIOCLGIFNUM failed: %s\n"), strerror(errno)); (void) close(sock); return (-1); } (void) close(sock); rcm_log_message(RCM_TRACE1, "IP: if_getcount success: %d\n", lifn.lifn_count); return (lifn.lifn_count); } /* * tokenize() - turn a command line into tokens; caller is responsible to * provide enough memory to hold all tokens */ static void tokenize(char *line, char **tokens, char *tspace, int *ntok) { char *cp; char *sp; sp = tspace; cp = line; for (*ntok = 0; *ntok < MAXARGS; (*ntok)++) { tokens[*ntok] = sp; while (ISSPACE(*cp)) cp++; if (ISEOL(*cp)) break; do { *sp++ = *cp++; } while (!ISSPACE(*cp) && !ISEOL(*cp)); *sp++ = '\0'; } }