xref: /illumos-gate/usr/src/cmd/cmd-inet/usr.lib/vrrpd/vrrpd.c (revision bbf21555)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/sysevent/vrrp.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/varargs.h>
#include <auth_attr.h>
#include <ctype.h>
#include <fcntl.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <unistd.h>
#include <zone.h>
#include <libsysevent.h>
#include <limits.h>
#include <locale.h>
#include <arpa/inet.h>
#include <signal.h>
#include <assert.h>
#include <ucred.h>
#include <bsm/adt.h>
#include <bsm/adt_event.h>
#include <priv_utils.h>
#include <libdllink.h>
#include <libdlvnic.h>
#include <libipadm.h>
#include <pwd.h>
#include <libvrrpadm.h>
#include <net/route.h>
#include "vrrpd_impl.h"

/*
 * A VRRP router can be only start participating the VRRP protocol of a virtual
 * router when all the following conditions are met:
 *
 * - The VRRP router is enabled (vr->vvr_conf.vvc_enabled is _B_TRUE)
 * - The RX socket is successfully created over the physical interface to
 *   receive the VRRP multicast advertisement. Note that one RX socket can
 *   be shared by several VRRP routers configured over the same physical
 *   interface. (See vrrpd_init_rxsock())
 * - The TX socket is successfully created over the VNIC interface to send
 *   the VRRP advertisment. (See vrrpd_init_txsock())
 * - The primary IP address has been successfully selected over the physical
 *   interface. (See vrrpd_select_primary())
 *
 * If a VRRP router is enabled but the other conditions haven't be satisfied,
 * the router will be stay at the VRRP_STATE_INIT state. If all the above
 * conditions are met, the VRRP router will be transit to either
 * the VRRP_STATE_MASTER or the VRRP_STATE_BACKUP state, depends on the VRRP
 * protocol.
 */

#define	skip_whitespace(p)	while (isspace(*(p))) ++(p)

#define	BUFFSIZE	65536

#define	VRRPCONF	"/etc/inet/vrrp.conf"

typedef struct vrrpd_rtsock_s {
	int		vrt_af;		/* address family */
	int		vrt_fd;		/* socket for the PF_ROUTE msg */
	iu_event_id_t	vrt_eid;	/* event ID */
} vrrpd_rtsock_t;

static ipadm_handle_t	vrrp_ipadm_handle = NULL;	/* libipadm handle */
static int		vrrp_logflag = 0;
boolean_t		vrrp_debug_level = 0;
iu_eh_t			*vrrpd_eh = NULL;
iu_tq_t			*vrrpd_timerq = NULL;
static vrrp_handle_t	vrrpd_vh = NULL;
static int		vrrpd_cmdsock_fd = -1;	/* socket to communicate */
						/* between vrrpd/libvrrpadm */
static iu_event_id_t	vrrpd_cmdsock_eid = -1;
static int		vrrpd_ctlsock_fd = -1;	/* socket to bring up/down */
						/* the virtual IP addresses */
static int		vrrpd_ctlsock6_fd = -1;
static vrrpd_rtsock_t	vrrpd_rtsocks[2] = {
	{AF_INET, -1, -1},
	{AF_INET6, -1, -1}
};
static iu_timer_id_t	vrrp_scan_timer_id = -1;

TAILQ_HEAD(vrrp_vr_list_s, vrrp_vr_s);
TAILQ_HEAD(vrrp_intf_list_s, vrrp_intf_s);
static struct vrrp_vr_list_s	vrrp_vr_list;
static struct vrrp_intf_list_s	vrrp_intf_list;
static char		vrrpd_conffile[MAXPATHLEN];

/*
 * Multicast address of VRRP advertisement in network byte order
 */
static vrrp_addr_t	vrrp_muladdr4;
static vrrp_addr_t	vrrp_muladdr6;

static int		vrrpd_scan_interval = 20000;	/* ms */
static int		pfds[2];

/*
 * macros to calculate skew_time and master_down_timer
 *
 * Note that the input is in centisecs and output are in msecs
 */
#define	SKEW_TIME(pri, intv)	((intv) * (256 - (pri)) / 256)
#define	MASTER_DOWN_INTERVAL(pri, intv)	(3 * (intv) + SKEW_TIME((pri), (intv)))

#define	SKEW_TIME_VR(vr)	\
	SKEW_TIME((vr)->vvr_conf.vvc_pri, (vr)->vvr_master_adver_int)
#define	MASTER_DOWN_INTERVAL_VR(vr)	\
	MASTER_DOWN_INTERVAL((vr)->vvr_conf.vvc_pri, (vr)->vvr_master_adver_int)

#define	VRRP_CONF_UPDATE	0x01
#define	VRRP_CONF_DELETE	0x02

static char *af_str(int);

static iu_tq_callback_t vrrp_adv_timeout;
static iu_tq_callback_t vrrp_b2m_timeout;
static iu_eh_callback_t vrrpd_sock_handler;
static iu_eh_callback_t vrrpd_rtsock_handler;
static iu_eh_callback_t vrrpd_cmdsock_handler;

static int daemon_init();

static vrrp_err_t vrrpd_init();
static void vrrpd_fini();
static vrrp_err_t vrrpd_cmdsock_create();
static void vrrpd_cmdsock_destroy();
static vrrp_err_t vrrpd_rtsock_create();
static void vrrpd_rtsock_destroy();
static vrrp_err_t vrrpd_ctlsock_create();
static void vrrpd_ctlsock_destroy();

static void vrrpd_scan_timer(iu_tq_t *, void *);
static void vrrpd_scan(int);
static vrrp_err_t vrrpd_init_rxsock(vrrp_vr_t *);
static void vrrpd_fini_rxsock(vrrp_vr_t *);
static vrrp_err_t vrrpd_init_txsock(vrrp_vr_t *);
static vrrp_err_t vrrpd_init_txsock_v4(vrrp_vr_t *);
static vrrp_err_t vrrpd_init_txsock_v6(vrrp_vr_t *);
static void vrrpd_fini_txsock(vrrp_vr_t *);

static vrrp_err_t vrrpd_create_vr(vrrp_vr_conf_t *);
static vrrp_err_t vrrpd_enable_vr(vrrp_vr_t *);
static void vrrpd_disable_vr(vrrp_vr_t *, vrrp_intf_t *, boolean_t);
static void vrrpd_delete_vr(vrrp_vr_t *);

static vrrp_err_t vrrpd_create(vrrp_vr_conf_t *, boolean_t);
static vrrp_err_t vrrpd_delete(const char *);
static vrrp_err_t vrrpd_enable(const char *, boolean_t);
static vrrp_err_t vrrpd_disable(const char *);
static vrrp_err_t vrrpd_modify(vrrp_vr_conf_t *, uint32_t);
static void vrrpd_list(vrid_t, char *, int, vrrp_ret_list_t *, size_t *);
static void vrrpd_query(const char *, vrrp_ret_query_t *, size_t *);

static boolean_t vrrp_rd_prop_name(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_vrid(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_af(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_pri(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_adver_int(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_preempt(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_accept(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_ifname(vrrp_vr_conf_t *, const char *);
static boolean_t vrrp_rd_prop_enabled(vrrp_vr_conf_t *, const char *);
static int vrrp_wt_prop_name(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_vrid(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_af(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_pri(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_adver_int(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_preempt(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_accept(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_ifname(vrrp_vr_conf_t *, char *, size_t);
static int vrrp_wt_prop_enabled(vrrp_vr_conf_t *, char *, size_t);

static void vrrpd_cmd_create(void *, void *, size_t *);
static void vrrpd_cmd_delete(void *, void *, size_t *);
static void vrrpd_cmd_enable(void *, void *, size_t *);
static void vrrpd_cmd_disable(void *, void *, size_t *);
static void vrrpd_cmd_modify(void *, void *, size_t *);
static void vrrpd_cmd_list(void *, void *, size_t *);
static void vrrpd_cmd_query(void *, void *, size_t *);

static vrrp_vr_t *vrrpd_lookup_vr_by_vrid(char *, vrid_t vrid_t, int);
static vrrp_vr_t *vrrpd_lookup_vr_by_name(const char *);
static vrrp_intf_t *vrrpd_lookup_if(const char *, int);
static vrrp_err_t vrrpd_create_if(const char *, int, uint32_t, vrrp_intf_t **);
static void vrrpd_delete_if(vrrp_intf_t *, boolean_t);
static vrrp_err_t vrrpd_create_ip(vrrp_intf_t *, const char *, vrrp_addr_t *,
    uint64_t flags);
static void vrrpd_delete_ip(vrrp_intf_t *, vrrp_ip_t *);

static void vrrpd_init_ipcache(int);
static void vrrpd_update_ipcache(int);
static ipadm_status_t vrrpd_walk_addr_info(int);
static vrrp_err_t vrrpd_add_ipaddr(char *, int, vrrp_addr_t *,
    int, uint64_t);
static vrrp_ip_t *vrrpd_select_primary(vrrp_intf_t *);
static void vrrpd_reselect_primary(vrrp_intf_t *);
static void vrrpd_reenable_all_vr();
static void vrrpd_remove_if(vrrp_intf_t *, boolean_t);

static uint16_t in_cksum(int, uint16_t, void *);
static uint16_t vrrp_cksum4(struct in_addr *, struct in_addr *,
    uint16_t, vrrp_pkt_t *);
static uint16_t vrrp_cksum6(struct in6_addr *, struct in6_addr *,
    uint16_t, vrrp_pkt_t *);
static size_t vrrpd_build_vrrp(vrrp_vr_t *, uchar_t *, int, boolean_t);

static void vrrpd_process_adv(vrrp_vr_t *, vrrp_addr_t *, vrrp_pkt_t *);
static vrrp_err_t vrrpd_send_adv(vrrp_vr_t *, boolean_t);

/* state transition functions */
static vrrp_err_t vrrpd_state_i2m(vrrp_vr_t *);
static vrrp_err_t vrrpd_state_i2b(vrrp_vr_t *);
static void vrrpd_state_m2i(vrrp_vr_t *);
static void vrrpd_state_b2i(vrrp_vr_t *);
static vrrp_err_t vrrpd_state_b2m(vrrp_vr_t *);
static vrrp_err_t vrrpd_state_m2b(vrrp_vr_t *);
static void vrrpd_state_trans(vrrp_state_t, vrrp_state_t, vrrp_vr_t *);

static vrrp_err_t vrrpd_set_noaccept(vrrp_vr_t *, boolean_t);
static vrrp_err_t vrrpd_virtualip_update(vrrp_vr_t *, boolean_t);
static vrrp_err_t vrrpd_virtualip_updateone(vrrp_intf_t *, vrrp_ip_t *,
    boolean_t);
static int vrrpd_post_event(const char *, vrrp_state_t, vrrp_state_t);

static void vrrpd_initconf();
static vrrp_err_t vrrpd_updateconf(vrrp_vr_conf_t *, uint_t);
static vrrp_err_t vrrpd_write_vrconf(char *, size_t, vrrp_vr_conf_t *);
static vrrp_err_t vrrpd_read_vrconf(char *, vrrp_vr_conf_t *);
static vrrp_err_t vrrpd_readprop(const char *, vrrp_vr_conf_t *);
static void vrrpd_cleanup();

static void vrrp_log(int, char *, ...);
static int timeval_to_milli(struct timeval);
static struct timeval timeval_delta(struct timeval, struct timeval);

typedef struct vrrpd_prop_s {
	char		*vs_propname;
	boolean_t	(*vs_propread)(vrrp_vr_conf_t *, const char *);
	int		(*vs_propwrite)(vrrp_vr_conf_t *, char *, size_t);
} vrrp_prop_t;

/*
 * persistent VRRP properties array
 */
static vrrp_prop_t vrrp_prop_info_tbl[] = {
	{"name", vrrp_rd_prop_name, vrrp_wt_prop_name},
	{"vrid", vrrp_rd_prop_vrid, vrrp_wt_prop_vrid},
	{"priority", vrrp_rd_prop_pri, vrrp_wt_prop_pri},
	{"adv_intval", vrrp_rd_prop_adver_int, vrrp_wt_prop_adver_int},
	{"preempt_mode", vrrp_rd_prop_preempt, vrrp_wt_prop_preempt},
	{"accept_mode", vrrp_rd_prop_accept, vrrp_wt_prop_accept},
	{"interface", vrrp_rd_prop_ifname, vrrp_wt_prop_ifname},
	{"af", vrrp_rd_prop_af, vrrp_wt_prop_af},
	{"enabled", vrrp_rd_prop_enabled, vrrp_wt_prop_enabled}
};

#define	VRRP_PROP_INFO_TABSIZE	\
	(sizeof (vrrp_prop_info_tbl) / sizeof (vrrp_prop_t))

typedef void vrrp_cmd_func_t(void *, void *, size_t *);

typedef struct vrrp_cmd_info_s {
	vrrp_cmd_type_t	vi_cmd;
	size_t		vi_reqsize;
	size_t		vi_acksize;	/* 0 if the size is variable */
	boolean_t	vi_setop;	/* Set operation? Check credentials */
	vrrp_cmd_func_t	*vi_cmdfunc;
} vrrp_cmd_info_t;

static vrrp_cmd_info_t vrrp_cmd_info_tbl[] = {
	{VRRP_CMD_CREATE, sizeof (vrrp_cmd_create_t),
	    sizeof (vrrp_ret_create_t), _B_TRUE, vrrpd_cmd_create},
	{VRRP_CMD_DELETE, sizeof (vrrp_cmd_delete_t),
	    sizeof (vrrp_ret_delete_t), _B_TRUE, vrrpd_cmd_delete},
	{VRRP_CMD_ENABLE, sizeof (vrrp_cmd_enable_t),
	    sizeof (vrrp_ret_enable_t), _B_TRUE, vrrpd_cmd_enable},
	{VRRP_CMD_DISABLE, sizeof (vrrp_cmd_disable_t),
	    sizeof (vrrp_ret_disable_t), _B_TRUE, vrrpd_cmd_disable},
	{VRRP_CMD_MODIFY, sizeof (vrrp_cmd_modify_t),
	    sizeof (vrrp_ret_modify_t), _B_TRUE, vrrpd_cmd_modify},
	{VRRP_CMD_QUERY, sizeof (vrrp_cmd_query_t), 0,
	    _B_FALSE, vrrpd_cmd_query},
	{VRRP_CMD_LIST, sizeof (vrrp_cmd_list_t), 0,
	    _B_FALSE, vrrpd_cmd_list}
};

#define	VRRP_DOOR_INFO_TABLE_SIZE	\
	(sizeof (vrrp_cmd_info_tbl) / sizeof (vrrp_cmd_info_t))

static int
ipaddr_cmp(int af, vrrp_addr_t *addr1, vrrp_addr_t *addr2)
{
	if (af == AF_INET) {
		return (memcmp(&addr1->in4.sin_addr,
		    &addr2->in4.sin_addr, sizeof (struct in_addr)));
	} else {
		return (memcmp(&addr1->in6.sin6_addr,
		    &addr2->in6.sin6_addr, sizeof (struct in6_addr)));
	}
}

static vrrp_vr_t *
vrrpd_lookup_vr_by_vrid(char *ifname, vrid_t vrid, int af)
{
	vrrp_vr_t *vr;

	TAILQ_FOREACH(vr, &vrrp_vr_list, vvr_next) {
		if (strcmp(vr->vvr_conf.vvc_link, ifname) == 0 &&
		    vr->vvr_conf.vvc_vrid == vrid &&
		    vr->vvr_conf.vvc_af == af) {
			break;
		}
	}
	return (vr);
}

static vrrp_vr_t *
vrrpd_lookup_vr_by_name(const char *name)
{
	vrrp_vr_t *vr;

	TAILQ_FOREACH(vr, &vrrp_vr_list, vvr_next) {
		if (strcmp(vr->vvr_conf.vvc_name, name) == 0)
			break;
	}
	return (vr);
}

static vrrp_intf_t *
vrrpd_lookup_if(const char *ifname, int af)
{
	vrrp_intf_t	*intf;

	TAILQ_FOREACH(intf, &vrrp_intf_list, vvi_next) {
		if (strcmp(ifname, intf->vvi_ifname) == 0 &&
		    af == intf->vvi_af) {
			break;
		}
	}
	return (intf);
}

static vrrp_err_t
vrrpd_create_if(const char *ifname, int af, uint32_t ifindex,
    vrrp_intf_t **intfp)
{
	vrrp_intf_t	*intf;

	vrrp_log(VRRP_DBG0, "vrrpd_create_if(%s, %s, %d)",
	    ifname, af_str(af), ifindex);

	if (((*intfp) = malloc(sizeof (vrrp_intf_t))) == NULL) {
		vrrp_log(VRRP_ERR, "vrrpd_create_if(): failed to "
		    "allocate %s/%s interface", ifname, af_str(af));
		return (VRRP_ENOMEM);
	}

	intf = *intfp;
	TAILQ_INIT(&intf->vvi_iplist);
	(void) strlcpy(intf->vvi_ifname, ifname, sizeof (intf->vvi_ifname));
	intf->vvi_af = af;
	intf->vvi_sockfd = -1;
	intf->vvi_nvr = 0;
	intf->vvi_eid = -1;
	intf->vvi_pip = NULL;
	intf->vvi_ifindex = ifindex;
	intf->vvi_state = NODE_STATE_NEW;
	intf->vvi_vr_state = VRRP_STATE_INIT;
	TAILQ_INSERT_TAIL(&vrrp_intf_list, intf, vvi_next);
	return (VRRP_SUCCESS);
}

/*
 * An interface is deleted. If update_vr is true, the deletion of the interface
 * may cause the state transition of assoicated VRRP router (if this interface
 * is either the primary or the VNIC interface of the VRRP router); otherwise,
 * simply delete the interface without updating the VRRP router.
 */
static void
vrrpd_delete_if(vrrp_intf_t *intf, boolean_t update_vr)
{
	vrrp_ip_t	*ip;

	vrrp_log(VRRP_DBG0, "vrrpd_delete_if(%s, %s, %supdate_vr)",
	    intf->vvi_ifname, af_str(intf->vvi_af), update_vr ? "" : "no_");

	if (update_vr) {
		/*
		 * If a this interface is the physical interface or the VNIC
		 * of a VRRP router, the deletion of the interface (no IP
		 * address exists on this interface) may cause the state
		 * transition of the VRRP router. call vrrpd_remove_if()
		 * to find all corresponding VRRP router and update their
		 * states.
		 */
		vrrpd_remove_if(intf, _B_FALSE);
	}

	/*
	 * First remove and delete all the IP addresses on the interface
	 */
	while (!TAILQ_EMPTY(&intf->vvi_iplist)) {
		ip = TAILQ_FIRST(&intf->vvi_iplist);
		vrrpd_delete_ip(intf, ip);
	}

	/*
	 * Then remove and delete the interface
	 */
	TAILQ_REMOVE(&vrrp_intf_list, intf, vvi_next);
	(void) free(intf);
}

static vrrp_err_t
vrrpd_create_ip(vrrp_intf_t *intf, const char *lifname, vrrp_addr_t *addr,
    uint64_t flags)
{
	vrrp_ip_t	*ip;
	char		abuf[INET6_ADDRSTRLEN];

	/* LINTED E_CONSTANT_CONDITION */
	VRRPADDR2STR(intf->vvi_af, addr, abuf, INET6_ADDRSTRLEN, _B_FALSE);
	vrrp_log(VRRP_DBG0, "vrrpd_create_ip(%s, %s, %s, 0x%x)",
	    intf->vvi_ifname, lifname, abuf, flags);

	if ((ip = malloc(sizeof (vrrp_ip_t))) == NULL) {
		vrrp_log(VRRP_ERR, "vrrpd_create_ip(%s, %s):"
		    "failed to allocate IP", lifname, abuf);
		return (VRRP_ENOMEM);
	}

	(void) strncpy(ip->vip_lifname, lifname, sizeof (ip->vip_lifname));
	ip->vip_state = NODE_STATE_NEW;
	ip->vip_flags = flags;
	(void) memcpy(&ip->vip_addr, addr, sizeof (ip->vip_addr));

	/*
	 * Make sure link-local IPv6 IP addresses are at the head of the list
	 */
	if (intf->vvi_af == AF_INET6 &&
	    IN6_IS_ADDR_LINKLOCAL(&addr->in6.sin6_addr)) {
		TAILQ_INSERT_HEAD(&intf->vvi_iplist, ip, vip_next);
	} else {
		TAILQ_INSERT_TAIL(&intf->vvi_iplist, ip, vip_next);
	}
	return (VRRP_SUCCESS);
}

static void
vrrpd_delete_ip(vrrp_intf_t *intf, vrrp_ip_t *ip)
{
	char	abuf[INET6_ADDRSTRLEN];
	int	af = intf->vvi_af;

	/* LINTED E_CONSTANT_CONDITION */
	VRRPADDR2STR(af, &ip->vip_addr, abuf, sizeof (abuf), _B_FALSE);
	vrrp_log(VRRP_DBG0, "vrrpd_delete_ip(%s, %s, %s) is %sprimary",
	    intf->vvi_ifname, ip->vip_lifname, abuf,
	    intf->vvi_pip == ip ? "" : "not ");

	if (intf->vvi_pip == ip)
		intf->vvi_pip = NULL;

	TAILQ_REMOVE(&intf->vvi_iplist, ip, vip_next);
	(void) free(ip);
}

static char *
rtm_event2str(uchar_t event)
{
	switch (event) {
	case RTM_NEWADDR:
		return ("RTM_NEWADDR");
	case RTM_DELADDR:
		return ("RTM_DELADDR");
	case RTM_IFINFO:
		return ("RTM_IFINFO");
	case RTM_ADD:
		return ("RTM_ADD");
	case RTM_DELETE:
		return ("RTM_DELETE");
	case RTM_CHANGE:
		return ("RTM_CHANGE");
	case RTM_OLDADD:
		return ("RTM_OLDADD");
	case RTM_OLDDEL:
		return ("RTM_OLDDEL");
	case RTM_CHGADDR:
		return ("RTM_CHGADDR");
	case RTM_FREEADDR:
		return ("RTM_FREEADDR");
	default:
		return ("RTM_OTHER");
	}
}

/*
 * This is called by the child process to inform the parent process to
 * exit with the given return value. Note that the child process
 * (the daemon process) informs the parent process to exit when anything
 * goes wrong or when all the intialization is done.
 */
static int
vrrpd_inform_parent_exit(int rv)
{
	int err = 0;

	/*
	 * If vrrp_debug_level is none-zero, vrrpd is not running as
	 * a daemon. Return directly.
	 */
	if (vrrp_debug_level != 0)
		return (0);

	if (write(pfds[1], &rv, sizeof (int)) != sizeof (int)) {
		err = errno;
		(void) close(pfds[1]);
		return (err);
	}
	(void) close(pfds[1]);
	return (0);
}

int
main(int argc, char *argv[])
{
	int c, err;
	struct sigaction sa;
	sigset_t mask;
	struct rlimit rl;

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	/*
	 * We need PRIV_SYS_CONFIG to post VRRP sysevent, PRIV_NET_RAWACESS
	 * and PRIV_NET_ICMPACCESS to open  the raw socket, PRIV_SYS_IP_CONFIG
	 * to bring up/down the virtual IP addresses, and PRIV_SYS_RESOURCE to
	 * setrlimit().
	 *
	 * Note that sysevent is not supported in non-global zones.
	 */
	if (getzoneid() == GLOBAL_ZONEID) {
		err = __init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET, 0, 0,
		    PRIV_SYS_CONFIG, PRIV_NET_RAWACCESS, PRIV_NET_ICMPACCESS,
		    PRIV_SYS_IP_CONFIG, PRIV_SYS_RESOURCE, NULL);
	} else {
		err = __init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET, 0, 0,
		    PRIV_NET_RAWACCESS, PRIV_NET_ICMPACCESS,
		    PRIV_SYS_IP_CONFIG, PRIV_SYS_RESOURCE, NULL);
	}

	if (err == -1) {
		vrrp_log(VRRP_ERR, "main(): init_daemon_priv() failed");
		return (EXIT_FAILURE);
	}

	/*
	 * If vrrpd is started by other process, it will inherit the
	 * signal block mask. We unblock all signals to make sure the
	 * signal handling will work normally.
	 */
	(void) sigfillset(&mask);
	(void) thr_sigsetmask(SIG_UNBLOCK, &mask, NULL);
	sa.sa_handler = vrrpd_cleanup;
	sa.sa_flags = 0;
	(void) sigemptyset(&sa.sa_mask);
	(void) sigaction(SIGINT, &sa, NULL);
	(void) sigaction(SIGQUIT, &sa, NULL);
	(void) sigaction(SIGTERM, &sa, NULL);

	vrrp_debug_level = 0;
	(void) strlcpy(vrrpd_conffile, VRRPCONF, sizeof (vrrpd_conffile));
	while ((c = getopt(argc, argv, "d:f:")) != EOF) {
		switch (c) {
		case 'd':
			vrrp_debug_level = atoi(optarg);
			break;
		case 'f':
			(void) strlcpy(vrrpd_conffile, optarg,
			    sizeof (vrrpd_conffile));
			break;
		default:
			break;
		}
	}

	closefrom(3);
	if (vrrp_debug_level == 0 && (daemon_init() != 0)) {
		vrrp_log(VRRP_ERR, "main(): daemon_init() failed");
		return (EXIT_FAILURE);
	}

	rl.rlim_cur = RLIM_INFINITY;
	rl.rlim_max = RLIM_INFINITY;
	if (setrlimit(RLIMIT_NOFILE, &rl) == -1) {
		vrrp_log(VRRP_ERR, "main(): setrlimit() failed");
		goto child_out;
	}

	if (vrrpd_init() != VRRP_SUCCESS) {
		vrrp_log(VRRP_ERR, "main(): vrrpd_init() failed");
		goto child_out;
	}

	/*
	 * Get rid of unneeded privileges.
	 */
	__fini_daemon_priv(PRIV_PROC_FORK, PRIV_PROC_EXEC, PRIV_PROC_SESSION,
	    PRIV_FILE_LINK_ANY, PRIV_PROC_INFO, PRIV_SYS_RESOURCE, NULL);

	/*
	 * Read the configuration and initialize the existing VRRP
	 * configuration
	 */
	vrrpd_initconf();

	/*
	 * Inform the parent process that it can successfully exit.
	 */
	if ((err = vrrpd_inform_parent_exit(EXIT_SUCCESS)) != 0) {
		vrrpd_cleanup();
		vrrp_log(VRRP_WARNING, "vrrpd_inform_parent_exit() failed: %s",
		    strerror(err));
		return (EXIT_FAILURE);
	}

	/*
	 * Start the loop to handle the timer and the IO events.
	 */
	switch (iu_handle_events(vrrpd_eh, vrrpd_timerq)) {
	case -1:
		vrrp_log(VRRP_ERR, "main(): iu_handle_events() failed "
		    "abnormally");
		break;
	default:
		break;
	}

	vrrpd_cleanup();
	return (EXIT_SUCCESS);

child_out:
	(void) vrrpd_inform_parent_exit(EXIT_FAILURE);
	return (EXIT_FAILURE);
}

static int
daemon_init()
{
	pid_t	pid;
	int	rv;

	vrrp_log(VRRP_DBG0, "daemon_init()");

	if (getenv("SMF_FMRI") == NULL) {
		vrrp_log(VRRP_ERR, "daemon_init(): vrrpd is an smf(7) managed "
		    "service and should not be run from the command line.");
		return (-1);
	}

	/*
	 * Create the pipe used for the child process to inform the parent
	 * process to exit after all initialization is done.
	 */
	if (pipe(pfds) < 0) {
		vrrp_log(VRRP_ERR, "daemon_init(): pipe() failed: %s",
		    strerror(errno));
		return (-1);
	}

	if ((pid = fork()) < 0) {
		vrrp_log(VRRP_ERR, "daemon_init(): fork() failed: %s",
		    strerror(errno));
		(void) close(pfds[0]);
		(void) close(pfds[1]);
		return (-1);
	}

	if (pid != 0) { /* Parent */
		(void) close(pfds[1]);

		/*
		 * Read the child process's return value from the pfds.
		 * If the child process exits unexpectedly, read() returns -1.
		 */
		if (read(pfds[0], &rv, sizeof (int)) != sizeof (int)) {
			vrrp_log(VRRP_ERR, "daemon_init(): child process "
			    "exited unexpectedly %s", strerror(errno));
			(void) kill(pid, SIGTERM);
			rv = EXIT_FAILURE;
		}
		(void) close(pfds[0]);
		exit(rv);
	}

	/*
	 * in child process, became a daemon, and return to main() to continue.
	 */
	(void) close(pfds[0]);
	(void) chdir("/");
	(void) setsid();
	(void) close(0);
	(void) close(1);
	(void) close(2);
	(void) open("/dev/null", O_RDWR, 0);
	(void) dup2(0, 1);
	(void) dup2(0, 2);
	openlog("vrrpd", LOG_PID, LOG_DAEMON);
	vrrp_logflag = 1;
	return (0);
}

static vrrp_err_t
vrrpd_init()
{
	vrrp_err_t	err = VRRP_ESYS;

	vrrp_log(VRRP_DBG0, "vrrpd_init()");

	TAILQ_INIT(&vrrp_vr_list);
	TAILQ_INIT(&vrrp_intf_list);

	if (vrrp_open(&vrrpd_vh) != VRRP_SUCCESS) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): vrrp_open() failed");
		goto fail;
	}

	if ((vrrpd_timerq = iu_tq_create()) == NULL) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): iu_tq_create() failed");
		goto fail;
	}

	if ((vrrpd_eh = iu_eh_create()) == NULL) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): iu_eh_create() failed");
		goto fail;
	}

	/*
	 * Create the AF_UNIX socket used to communicate with libvrrpadm.
	 *
	 * This socket is used to receive the administrative requests and
	 * send back the results.
	 */
	if (vrrpd_cmdsock_create() != VRRP_SUCCESS) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): vrrpd_cmdsock_create() "
		    "failed");
		goto fail;
	}

	/*
	 * Create the VRRP control socket used to bring up/down the virtual
	 * IP addresses. It is also used to set the IFF_NOACCEPT flag of
	 * the virtual IP addresses.
	 */
	if (vrrpd_ctlsock_create() != VRRP_SUCCESS) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): vrrpd_ctlsock_create() "
		    "failed");
		goto fail;
	}

	/*
	 * Create the PF_ROUTER socket used to listen to the routing socket
	 * messages and build the interface/IP address list.
	 */
	if (vrrpd_rtsock_create() != VRRP_SUCCESS) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): vrrpd_rtsock_create() "
		    "failed");
		goto fail;
	}

	/* Open the libipadm handle */
	if (ipadm_open(&vrrp_ipadm_handle, 0) != IPADM_SUCCESS) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): ipadm_open() failed");
		goto fail;
	}

	/*
	 * Build the list of interfaces and IP addresses. Also, start the time
	 * to scan the interfaces/IP addresses periodically.
	 */
	vrrpd_scan(AF_INET);
	vrrpd_scan(AF_INET6);
	if ((vrrp_scan_timer_id = iu_schedule_timer_ms(vrrpd_timerq,
	    vrrpd_scan_interval, vrrpd_scan_timer, NULL)) == -1) {
		vrrp_log(VRRP_ERR, "vrrpd_init(): start scan_timer failed");
		goto fail;
	}

	/*
	 * Initialize the VRRP multicast address.
	 */
	bzero(&vrrp_muladdr4, sizeof (vrrp_addr_t));
	vrrp_muladdr4.in4.sin_family = AF_INET;
	(void) inet_pton(AF_INET, "224.0.0.18", &vrrp_muladdr4.in4.sin_addr);

	bzero(&vrrp_muladdr6, sizeof (vrrp_addr_t));
	vrrp_muladdr6.in6.sin6_family = AF_INET6;
	(void) inet_pton(AF_INET6, "ff02::12", &vrrp_muladdr6.in6.sin6_addr);

	return (VRRP_SUCCESS);

fail:
	vrrpd_fini();
	return (err);
}

static void
vrrpd_fini()
{
	vrrp_log(VRRP_DBG0, "vrrpd_fini()");

	(void) iu_cancel_timer(vrrpd_timerq, vrrp_scan_timer_id, NULL);
	vrrp_scan_timer_id = -1;

	vrrpd_rtsock_destroy();
	vrrpd_ctlsock_destroy();
	vrrpd_cmdsock_destroy();

	if (vrrpd_eh != NULL) {
		iu_eh_destroy(vrrpd_eh);
		vrrpd_eh = NULL;
	}

	if (vrrpd_timerq != NULL) {
		iu_tq_destroy(vrrpd_timerq);
		vrrpd_timerq = NULL;
	}

	vrrp_close(vrrpd_vh);
	vrrpd_vh = NULL;
	assert(TAILQ_EMPTY(&vrrp_vr_list));
	assert(TAILQ_EMPTY(&vrrp_intf_list));

	ipadm_close(vrrp_ipadm_handle);
}

static void
vrrpd_cleanup(void)
{
	vrrp_vr_t	*vr;
	vrrp_intf_t	*intf;

	vrrp_log(VRRP_DBG0, "vrrpd_cleanup()");

	while (!TAILQ_EMPTY(&vrrp_vr_list)) {
		vr = TAILQ_FIRST(&vrrp_vr_list);
		vrrpd_delete_vr(vr);
	}

	while (!TAILQ_EMPTY(&vrrp_intf_list)) {
		intf = TAILQ_FIRST(&vrrp_intf_list);
		vrrpd_delete_if(intf, _B_FALSE);
	}

	vrrpd_fini();
	closelog();
	exit(1);
}

/*
 * Read the configuration file and initialize all the existing VRRP routers.
 */
static void
vrrpd_initconf()
{
	FILE *fp;
	char line[LINE_MAX];
	int linenum = 0;
	vrrp_vr_conf_t conf;
	vrrp_err_t err;

	vrrp_log(VRRP_DBG0, "vrrpd_initconf()");

	if ((fp = fopen(vrrpd_conffile, "rF")) == NULL) {
		vrrp_log(VRRP_ERR, "failed to open the configuration file %s",
		    vrrpd_conffile);
		return;
	}

	while (fgets(line, sizeof (line), fp) != NULL) {
		linenum++;
		conf.vvc_vrid = VRRP_VRID_NONE;
		if ((err = vrrpd_read_vrconf(line, &conf)) != VRRP_SUCCESS) {
			vrrp_log(VRRP_ERR, "failed to parse %d line %s",
			    linenum, line);
			continue;
		}

		/*
		 * Blank or comment line
		 */
		if (conf.vvc_vrid == VRRP_VRID_NONE)
			continue;

		/*
		 * No need to update the configuration since the VRRP router
		 * created/enabled based on the existing configuration.
		 */
		if ((err = vrrpd_create(&conf, _B_FALSE)) != VRRP_SUCCESS) {
			vrrp_log(VRRP_ERR, "VRRP router %s creation failed: "
			    "%s", conf.vvc_name, vrrp_err2str(err));
			continue;
		}

		if (conf.vvc_enabled &&
		    ((err = vrrpd_enable(conf.vvc_name, _B_FALSE)) !=
		    VRRP_SUCCESS)) {
			vrrp_log(VRRP_ERR, "VRRP router %s enable failed: %s",
			    conf.vvc_name, vrrp_err2str(err));
		}
	}

	(void) fclose(fp);
}

/*
 * Create the AF_UNIX socket used to communicate with libvrrpadm.
 *
 * This socket is used to receive the administrative request and
 * send back the results.
 */
static vrrp_err_t
vrrpd_cmdsock_create()
{
	iu_event_id_t		eid;
	struct sockaddr_un	laddr;
	int			sock, flags;

	vrrp_log(VRRP_DBG0, "vrrpd_cmdsock_create()");

	if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
		vrrp_log(VRRP_ERR, "vrrpd_cmdsock_create(): socket(AF_UNIX) "
		    "failed: %s", strerror(errno));
		return (VRRP_ESYS);
	}