OpenSolaris_b135/cmd/rcm_daemon/common/ip_anon_rcm.c
/*
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* RCM module to prevent plumbed IP addresses from being removed.
*/
#include <stdlib.h>
#include <ctype.h>
#include <memory.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <thread.h>
#include <synch.h>
#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <sys/param.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/cladm.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/time.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/ip6.h>
#include <inet/ip.h>
#include <inet/ip6.h>
#include <libinetutil.h>
#include "rcm_module.h"
#define SUNW_IP "SUNW_ip/"
#define IP_REG_SIZE (9 + INET6_ADDRSTRLEN)
#define IP_ANON_USAGE gettext("Plumbed IP Address")
#define IP_SUSPEND_ERR gettext("Plumbed IP Addresses cannot be suspended")
#define IP_OFFLINE_ERR gettext("Invalid operation: IP cannot be offlined")
#define IP_REMOVE_ERR gettext("Invalid operation: IP cannot be removed")
#define IP_REG_FAIL gettext("Registration Failed")
#define IP_NO_CLUSTER gettext("Could not read cluster network addresses")
#define IP_FLAG_NEW 0x00
#define IP_FLAG_REG 0x01
#define IP_FLAG_CL 0x02
#define IP_FLAG_IGNORE 0x04
#define IP_FLAG_DELETE 0x08
static int ip_anon_register(rcm_handle_t *);
static int ip_anon_unregister(rcm_handle_t *);
static int ip_anon_getinfo(rcm_handle_t *, char *, id_t, uint_t,
char **, char **, nvlist_t *, rcm_info_t **);
static int ip_anon_suspend(rcm_handle_t *, char *, id_t,
timespec_t *, uint_t, char **, rcm_info_t **);
static int ip_anon_resume(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int ip_anon_offline(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int ip_anon_online(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int ip_anon_remove(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int exclude_ipv4(cladm_netaddrs_t exclude_addrs,
ipaddr_t address);
static int exclude_ipv6(cladm_netaddrs_t exclude_addrs,
uint32_t address[4]);
typedef struct ip_status {
int flags;
char device[IP_REG_SIZE];
struct ip_status *next;
} ip_status_t;
static ip_status_t *findreg(char *reg);
static ip_status_t *addreg(char *reg);
static int deletereg(ip_status_t *entry);
static ip_status_t *ip_list = NULL;
static mutex_t ip_list_lock;
static struct rcm_mod_ops ip_anon_ops =
{
RCM_MOD_OPS_VERSION,
ip_anon_register,
ip_anon_unregister,
ip_anon_getinfo,
ip_anon_suspend,
ip_anon_resume,
ip_anon_offline,
ip_anon_online,
ip_anon_remove,
NULL,
NULL,
NULL
};
struct rcm_mod_ops *
rcm_mod_init()
{
return (&ip_anon_ops);
}
const char *
rcm_mod_info()
{
return ("RCM IP address module 1.4");
}
int
rcm_mod_fini()
{
ip_status_t *tlist;
/* free the registration list */
(void) mutex_lock(&ip_list_lock);
while (ip_list != NULL) {
tlist = ip_list->next;
free(ip_list);
ip_list = tlist;
}
(void) mutex_unlock(&ip_list_lock);
(void) mutex_destroy(&ip_list_lock);
return (RCM_SUCCESS);
}
static int
ip_anon_register(rcm_handle_t *hdl)
{
int bootflags;
struct ifaddrlist *al = NULL, *al6 = NULL;
char errbuf[ERRBUFSIZE];
char treg[IP_REG_SIZE], tstr[IP_REG_SIZE];
cladm_netaddrs_t exclude_addrs;
int num_ifs, num_ifs6, i, ret;
uint32_t num_exclude_addrs = 0;
ip_status_t *tlist, *tentry;
(void) mutex_lock(&ip_list_lock);
rcm_log_message(RCM_DEBUG, "ip_anon: registration refresh.\n");
exclude_addrs.cladm_num_netaddrs = 0;
if (_cladm(CL_INITIALIZE, CL_GET_BOOTFLAG, &bootflags) != 0) {
rcm_log_message(RCM_ERROR,
gettext("unable to check cluster status\n"));
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
rcm_log_message(RCM_DEBUG,
"ip_anon: cladm bootflags=%d\n", bootflags);
if (bootflags == 3) {
/* build the exclusion list */
if ((ret = _cladm(CL_CONFIG, CL_GET_NUM_NETADDRS,
&num_exclude_addrs)) == 0) {
exclude_addrs.cladm_num_netaddrs = num_exclude_addrs;
if (num_exclude_addrs == 0)
rcm_log_message(RCM_DEBUG,
"ip_anon: no addresses excluded\n");
else {
if ((exclude_addrs.cladm_netaddrs_array =
malloc(sizeof (cladm_netaddr_entry_t) *
(num_exclude_addrs))) == NULL) {
rcm_log_message(RCM_ERROR,
gettext("out of memory\n"));
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
if ((ret = _cladm(CL_CONFIG,
CL_GET_NETADDRS, &exclude_addrs))
!= 0) {
rcm_log_message(RCM_ERROR,
IP_NO_CLUSTER);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
}
} else {
if ((ret != 0) && (errno == EINVAL)) {
rcm_log_message(RCM_DEBUG,
"no _cladm() backend to get addrs\n");
} else {
rcm_log_message(RCM_ERROR, IP_NO_CLUSTER);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
}
rcm_log_message(RCM_DEBUG,
"cladm returned %d errno=%d\n", ret, errno);
rcm_log_message(RCM_DEBUG,
"ip_anon: num exclude addrs: %d\n",
exclude_addrs.cladm_num_netaddrs);
/* print the exclusion list for debugging purposes */
for (i = 0; i < exclude_addrs.cladm_num_netaddrs; i++) {
(void) strcpy(treg, "<UNKNOWN>");
(void) strcpy(tstr, "<UNKNOWN>");
if (exclude_addrs.cladm_netaddrs_array[i].\
cl_ipversion == IPV4_VERSION) {
(void) inet_ntop(AF_INET,
&exclude_addrs.cladm_netaddrs_array[i].
cl_ipv_un.cl_ipv4.ipv4_netaddr,
treg, INET_ADDRSTRLEN);
(void) inet_ntop(AF_INET,
&exclude_addrs.cladm_netaddrs_array[i].
cl_ipv_un.cl_ipv4.ipv4_netmask,
tstr, INET_ADDRSTRLEN);
}
if (exclude_addrs.cladm_netaddrs_array[i].\
cl_ipversion == IPV6_VERSION) {
(void) inet_ntop(AF_INET6,
&exclude_addrs.cladm_netaddrs_array[i].
cl_ipv_un.cl_ipv6.ipv6_netaddr,
treg, INET6_ADDRSTRLEN);
(void) inet_ntop(AF_INET6,
&exclude_addrs.cladm_netaddrs_array[i].
cl_ipv_un.cl_ipv6.ipv6_netmask,
tstr, INET6_ADDRSTRLEN);
}
rcm_log_message(RCM_DEBUG, "IPV%d: %s %s\n",
exclude_addrs.cladm_netaddrs_array[i].
cl_ipversion, treg, tstr);
}
}
/* obtain a list of all IPv4 and IPv6 addresses in the system */
rcm_log_message(RCM_DEBUG,
"ip_anon: obtaining list of IPv4 addresses.\n");
num_ifs = ifaddrlist(&al, AF_INET, LIFC_UNDER_IPMP, errbuf);
if (num_ifs == -1) {
rcm_log_message(RCM_ERROR,
gettext("cannot get IPv4 address list errno=%d (%s)\n"),
errno, errbuf);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
rcm_log_message(RCM_DEBUG,
"ip_anon: obtaining list of IPv6 addresses.\n");
num_ifs6 = ifaddrlist(&al6, AF_INET6, LIFC_UNDER_IPMP, errbuf);
if (num_ifs6 == -1) {
rcm_log_message(RCM_ERROR,
gettext("cannot get IPv6 address list errno=%d (%s)\n"),
errno, errbuf);
free(al);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
/* check the state of outstanding registrations against the list */
rcm_log_message(RCM_DEBUG,
"ip_anon: checking outstanding registrations.\n");
tlist = ip_list;
while (tlist != NULL) {
tlist->flags |= IP_FLAG_DELETE;
tlist = tlist->next;
}
/* IPv4 */
rcm_log_message(RCM_DEBUG, "ip_anon: checking IPv4 addresses.\n");
for (i = 0; i < num_ifs; i++) {
(void) inet_ntop(AF_INET, &al[i].addr.addr, tstr,
INET_ADDRSTRLEN);
(void) strcpy(treg, SUNW_IP);
(void) strcat(treg, tstr);
if ((tlist = findreg(treg)) == NULL)
tlist = addreg(treg);
else
tlist->flags &= (~IP_FLAG_DELETE);
if (tlist == NULL) {
rcm_log_message(RCM_ERROR,
gettext("out of memory\n"));
free(al);
free(al6);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
if (exclude_ipv4(exclude_addrs, al[i].addr.addr.s_addr))
tlist->flags |= IP_FLAG_CL;
}
/* IPv6 */
rcm_log_message(RCM_DEBUG, "ip_anon: checking IPv6 addresses.\n");
for (i = 0; i < num_ifs6; i++) {
(void) inet_ntop(AF_INET6, &al6[i].addr.addr, tstr,
INET6_ADDRSTRLEN);
(void) strcpy(treg, SUNW_IP);
(void) strcat(treg, tstr);
if ((tlist = findreg(treg)) == NULL)
tlist = addreg(treg);
else
tlist->flags &= (~IP_FLAG_DELETE);
if (tlist == NULL) {
rcm_log_message(RCM_ERROR,
gettext("out of memory\n"));
free(al);
free(al6);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
}
if (exclude_ipv6(exclude_addrs, al6[i].addr.addr6._S6_un.\
_S6_u32))
tlist->flags |= IP_FLAG_CL;
}
rcm_log_message(RCM_DEBUG, "ip_anon: updating reg. state.\n");
/* examine the list of ip address registrations and their state */
tlist = ip_list;
while (tlist != NULL) {
tentry = tlist;
tlist = tlist->next;
if (tentry->flags & IP_FLAG_DELETE) {
if (tentry->flags & IP_FLAG_REG) {
rcm_log_message(RCM_DEBUG,
"ip_anon: unregistering interest in %s\n",
tentry->device);
if (rcm_unregister_interest(hdl,
tentry->device, 0) != 0) {
rcm_log_message(RCM_ERROR,
gettext("failed to unregister"));
}
}
(void) deletereg(tentry);
} else if (!(tentry->flags & IP_FLAG_IGNORE)) {
/*
* If the registration is not a clustered devices and
* not already registered, then RCM doesn't
* currently know about it.
*/
if (!(tentry->flags & IP_FLAG_CL) &&
!(tentry->flags & IP_FLAG_REG)) {
tentry->flags |= IP_FLAG_REG;
rcm_log_message(RCM_DEBUG,
"ip_anon: registering interest in %s\n",
tentry->device);
if (rcm_register_interest(hdl,
tentry->device, 0, NULL) !=
RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
IP_REG_FAIL);
free(al);
free(al6);
(void) mutex_unlock(&ip_list_lock);
return (RCM_FAILURE);
} else {
rcm_log_message(RCM_DEBUG,
"ip_anon: registered %s\n",
tentry->device);
}
}
/*
* If the entry is registered and clustered, then
* the configuration has been changed and it
* should be unregistered.
*/
if ((tentry->flags & IP_FLAG_REG) &
(tentry->flags & IP_FLAG_CL)) {
rcm_log_message(RCM_DEBUG,
"ip_anon: unregistering in %s\n",
tentry->device);
if (rcm_unregister_interest(hdl,
tentry->device, 0) != 0) {
rcm_log_message(RCM_ERROR,
gettext("failed to unregister"));
}
tentry->flags &= (~IP_FLAG_REG);
}
}
}
tlist = ip_list;
while (tlist != NULL) {
rcm_log_message(RCM_DEBUG, "ip_anon: %s (%Xh)\n",
tlist->device, tlist->flags);
tlist = tlist->next;
}
rcm_log_message(RCM_DEBUG, "ip_anon: registration complete.\n");
free(al);
free(al6);
(void) mutex_unlock(&ip_list_lock);
return (RCM_SUCCESS);
}
static int
ip_anon_unregister(rcm_handle_t *hdl)
{
ip_status_t *tlist;
(void) mutex_lock(&ip_list_lock);
tlist = ip_list;
while (tlist != NULL) {
if ((tlist->flags & IP_FLAG_REG)) {
if (rcm_unregister_interest(hdl,
tlist->device, 0) != 0) {
rcm_log_message(RCM_ERROR,
gettext("failed to unregister"));
}
tlist->flags &= (~IP_FLAG_REG);
}
tlist = tlist->next;
}
(void) mutex_unlock(&ip_list_lock);
return (RCM_SUCCESS);
}
/*ARGSUSED*/
static int
ip_anon_getinfo(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **infostr, char **errstr, nvlist_t *props, rcm_info_t **dependent)
{
assert(rsrcname != NULL && infostr != NULL);
if ((*infostr = strdup(IP_ANON_USAGE)) == NULL)
rcm_log_message(RCM_ERROR, gettext("strdup failure\n"));
return (RCM_SUCCESS);
}
/*ARGSUSED*/
static int
ip_anon_suspend(rcm_handle_t *hdl, char *rsrcname, id_t id,
timespec_t *interval, uint_t flags, char **errstr,
rcm_info_t **dependent)
{
if ((*errstr = strdup(IP_SUSPEND_ERR)) == NULL)
rcm_log_message(RCM_ERROR, gettext("strdup failure\n"));
return (RCM_FAILURE);
}
/*ARGSUSED*/
static int
ip_anon_resume(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
return (RCM_SUCCESS);
}
/*ARGSUSED*/
static int
ip_anon_offline(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
if ((*errstr = strdup(IP_OFFLINE_ERR)) == NULL)
rcm_log_message(RCM_ERROR, gettext("strdup failure\n"));
return (RCM_FAILURE);
}
/*ARGSUSED*/
static int
ip_anon_online(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
return (RCM_SUCCESS);
}
/*ARGSUSED*/
static int
ip_anon_remove(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
if ((*errstr = strdup(IP_REMOVE_ERR)) == NULL)
rcm_log_message(RCM_ERROR, gettext("strdup failure\n"));
return (RCM_FAILURE);
}
/*
* Call with ip_list_lock held.
*/
static ip_status_t *
findreg(char *reg)
{
ip_status_t *tlist;
int done;
tlist = ip_list;
done = 0;
while ((tlist != NULL) && (!done)) {
if (strcmp(tlist->device, reg) == 0)
done = 1;
else
tlist = tlist->next;
}
return (tlist);
}
static ip_status_t *
addreg(char *reg)
{
ip_status_t *tlist, *tentry;
tentry = (ip_status_t *)malloc(sizeof (ip_status_t));
if (tentry == NULL)
return (tentry);
tentry->flags = IP_FLAG_NEW;
tentry->next = NULL;
(void) strcpy(tentry->device, reg);
if (ip_list == NULL)
ip_list = tentry;
else {
tlist = ip_list;
while (tlist->next != NULL)
tlist = tlist->next;
tlist->next = tentry;
}
return (tentry);
}
static int
deletereg(ip_status_t *entry)
{
ip_status_t *tlist;
if (entry == NULL)
return (-1);
if (entry == ip_list) {
ip_list = ip_list->next;
free(entry);
} else {
tlist = ip_list;
while ((tlist->next != NULL) && (tlist->next != entry))
tlist = tlist->next;
if (tlist->next != entry)
return (-1);
tlist->next = entry->next;
free(entry);
}
return (0);
}
static int
exclude_ipv4(cladm_netaddrs_t exclude_addrs, ipaddr_t address)
{
int i;
char taddr[IP_REG_SIZE], tmask[IP_REG_SIZE], tmatch[IP_REG_SIZE];
ipaddr_t ipv4_netaddr, ipv4_netmask;
(void) inet_ntop(AF_INET, &address, taddr, INET_ADDRSTRLEN);
rcm_log_message(RCM_DEBUG, "ip_anon: exclude_ipv4 (%s, %d)\n",
taddr, exclude_addrs.cladm_num_netaddrs);
/*
* If this falls in the exclusion list, the IP_FLAG_CL
* bit should be set for the adapter.
*/
for (i = 0; i < exclude_addrs.cladm_num_netaddrs; i++) {
if (exclude_addrs.cladm_netaddrs_array[i].\
cl_ipversion == IPV4_VERSION) {
ipv4_netaddr = exclude_addrs.\
cladm_netaddrs_array[i].cl_ipv_un.cl_ipv4.\
ipv4_netaddr;
ipv4_netmask = exclude_addrs.\
cladm_netaddrs_array[i].cl_ipv_un.cl_ipv4.\
ipv4_netmask;
(void) inet_ntop(AF_INET, &ipv4_netaddr, tmatch,
INET_ADDRSTRLEN);
(void) inet_ntop(AF_INET, &ipv4_netmask, tmask,
INET_ADDRSTRLEN);
if ((address & ipv4_netmask) == ipv4_netaddr) {
rcm_log_message(RCM_DEBUG,
"ip_anon: matched %s:%s => %s\n",
taddr, tmask, tmatch);
return (1);
}
}
}
rcm_log_message(RCM_DEBUG, "ip_anon: no match for %s\n",
taddr);
return (0);
}
static int
exclude_ipv6(cladm_netaddrs_t exclude_addrs, uint32_t address[4])
{
int i, j, numequal;
uint32_t addr[4], ipv6_netaddr[4], ipv6_netmask[4];
char taddr[IP_REG_SIZE], tmask[IP_REG_SIZE], tmatch[IP_REG_SIZE];
(void) inet_ntop(AF_INET6, address, taddr, INET6_ADDRSTRLEN);
/*
* If this falls in the exclusion list, the IP_FLAG_CL
* bit should be set for the adapter.
*/
for (i = 0; i < exclude_addrs.cladm_num_netaddrs; i++) {
if (exclude_addrs.cladm_netaddrs_array[i].\
cl_ipversion == IPV6_VERSION) {
numequal = 0;
for (j = 0; j < 4; j++) {
ipv6_netaddr[j] = exclude_addrs.\
cladm_netaddrs_array[i].\
cl_ipv_un.cl_ipv6.ipv6_netaddr[j];
ipv6_netmask[j] = exclude_addrs.\
cladm_netaddrs_array[i].\
cl_ipv_un.cl_ipv6.ipv6_netmask[j];
addr[j] = address[j] & ipv6_netmask[j];
if (addr[j] == ipv6_netaddr[j])
numequal++;
}
(void) inet_ntop(AF_INET6, ipv6_netaddr, tmatch,
INET6_ADDRSTRLEN);
(void) inet_ntop(AF_INET6, ipv6_netmask, tmask,
INET6_ADDRSTRLEN);
if (numequal == 4)
return (1);
}
}
rcm_log_message(RCM_DEBUG, "ip_anon: no match for %s\n",
taddr);
return (0);
}