/*
 * 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) 2016 by Delphix. All rights reserved.
 */

#include <stdlib.h>
#include <strings.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/list.h>
#include <assert.h>
#include <errno.h>
#include <libilb.h>
#include <net/if.h>
#include <inet/ilb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "libilb_impl.h"
#include "ilbd.h"

typedef enum {
        not_searched,
        stop_found,
        cont_search,
        fail_search
} srch_ind_t;

static list_t   ilbd_sg_hlist;

static ilb_status_t i_delete_srv(ilbd_sg_t *, ilbd_srv_t *, int);
static void i_ilbd_free_srvID(ilbd_sg_t *, int32_t);

/* Last parameter to pass to i_find_srv(), specifying the matching mode */
#define MODE_ADDR       1
#define MODE_SRVID      2

static ilbd_srv_t *i_find_srv(list_t *, ilb_sg_srv_t *, int);

void
i_setup_sg_hlist(void)
{
        list_create(&ilbd_sg_hlist, sizeof (ilbd_sg_t),
            offsetof(ilbd_sg_t, isg_link));
}

/*
 * allocate storage for a daemon-internal server group, init counters
 */
static ilbd_sg_t *
i_ilbd_alloc_sg(char *name)
{
        ilbd_sg_t       *d_sg;

        d_sg = calloc(sizeof (*d_sg), 1);
        if (d_sg == NULL)
                goto out;

        (void) strlcpy(d_sg->isg_name, name, sizeof (d_sg->isg_name));

        list_create(&d_sg->isg_srvlist, sizeof (ilbd_srv_t),
            offsetof(ilbd_srv_t, isv_srv_link));
        list_create(&d_sg->isg_rulelist, sizeof (ilbd_rule_t),
            offsetof(ilbd_rule_t, irl_sglink));

        list_insert_tail(&ilbd_sg_hlist, d_sg);
out:
        return (d_sg);
}

static ilb_status_t
i_ilbd_save_sg(ilbd_sg_t *d_sg, ilbd_scf_cmd_t scf_cmd, const char *prop_name,
    char *valstr)
{
        switch (scf_cmd) {
        case ILBD_SCF_CREATE:
                return (ilbd_create_pg(ILBD_SCF_SG, (void *)d_sg));
        case ILBD_SCF_DESTROY:
                return (ilbd_destroy_pg(ILBD_SCF_SG, d_sg->isg_name));
        case ILBD_SCF_ENABLE_DISABLE:
                if (prop_name == NULL)
                        return (ILB_STATUS_EINVAL);
                return (ilbd_change_prop(ILBD_SCF_SG, d_sg->isg_name,
                    prop_name, valstr));
        default:
                logdebug("i_ilbd_save_sg: invalid scf cmd %d", scf_cmd);
                return (ILB_STATUS_EINVAL);
        }
}

ilb_status_t
i_attach_rule2sg(ilbd_sg_t *sg, ilbd_rule_t *irl)
{
        /* assert: the same rule is attached to any sg only once */
        list_insert_tail(&sg->isg_rulelist, irl);
        return (ILB_STATUS_OK);
}

static void
i_ilbd_free_sg(ilbd_sg_t *sg)
{
        ilbd_srv_t *tmp_srv;

        if (sg == NULL)
                return;
        list_remove(&ilbd_sg_hlist, sg);
        while ((tmp_srv = list_remove_tail(&sg->isg_srvlist)) != NULL) {
                i_ilbd_free_srvID(sg, tmp_srv->isv_id);
                free(tmp_srv);
                sg->isg_srvcount--;
        }
        free(sg);
}

ilbd_sg_t *
i_find_sg_byname(const char *name)
{
        ilbd_sg_t *sg;

        /* find position of sg in list */
        for (sg = list_head(&ilbd_sg_hlist); sg != NULL;
            sg = list_next(&ilbd_sg_hlist, sg)) {
                if (strncmp(sg->isg_name, name, sizeof (sg->isg_name)) == 0)
                        return (sg);
        }
        return (sg);
}

/*
 * Generates an audit record for enable-server, disable-server, remove-server
 * delete-servergroup, create-servergroup and add-server subcommands.
 */
static void
ilbd_audit_server_event(audit_sg_event_data_t *data,
    ilbd_cmd_t cmd, ilb_status_t rc, ucred_t *ucredp)
{
        adt_session_data_t      *ah;
        adt_event_data_t        *event;
        au_event_t      flag;
        int     audit_error;

        if ((ucredp == NULL) && ((cmd == ILBD_ADD_SERVER_TO_GROUP) ||
            (cmd == ILBD_CREATE_SERVERGROUP)))  {
                /*
                 * We came here from the path where ilbd is
                 * incorporating the ILB configuration from
                 * SCF. In that case, we skip auditing
                 */
                return;
        }

        if (adt_start_session(&ah, NULL, 0) != 0) {
                logerr("ilbd_audit_server_event: adt_start_session failed");
                exit(EXIT_FAILURE);
        }

        if (adt_set_from_ucred(ah, ucredp, ADT_NEW) != 0) {
                (void) adt_end_session(ah);
                logerr("ilbd_audit_server_event: adt_set_from_ucred failed");
                exit(EXIT_FAILURE);
        }

        if (cmd == ILBD_ENABLE_SERVER)
                flag = ADT_ilb_enable_server;
        else if (cmd == ILBD_DISABLE_SERVER)
                flag = ADT_ilb_disable_server;
        else if (cmd == ILBD_REM_SERVER_FROM_GROUP)
                flag = ADT_ilb_remove_server;
        else if (cmd == ILBD_ADD_SERVER_TO_GROUP)
                flag = ADT_ilb_add_server;
        else if (cmd == ILBD_CREATE_SERVERGROUP)
                flag = ADT_ilb_create_servergroup;
        else if (cmd == ILBD_DESTROY_SERVERGROUP)
                flag = ADT_ilb_delete_servergroup;

        if ((event = adt_alloc_event(ah, flag)) == NULL) {
                logerr("ilbd_audit_server_event: adt_alloc_event failed");
                exit(EXIT_FAILURE);
        }
        (void) memset((char *)event, 0, sizeof (adt_event_data_t));

        switch (cmd) {
        case ILBD_ENABLE_SERVER:
                event->adt_ilb_enable_server.auth_used =
                    NET_ILB_ENABLE_AUTH;
                event->adt_ilb_enable_server.server_id =
                    data->ed_serverid;
                event->adt_ilb_enable_server.server_ipaddress_type =
                    data->ed_ipaddr_type;
                (void) memcpy(event->adt_ilb_enable_server.server_ipaddress,
                    data->ed_server_address,
                    (sizeof (data->ed_server_address)));
                break;
        case ILBD_DISABLE_SERVER:
                event->adt_ilb_disable_server.auth_used =
                    NET_ILB_ENABLE_AUTH;
                event->adt_ilb_disable_server.server_id =
                    data->ed_serverid;
                event->adt_ilb_disable_server.server_ipaddress_type =
                    data->ed_ipaddr_type;
                (void) memcpy(event->adt_ilb_disable_server.server_ipaddress,
                    data->ed_server_address,
                    (sizeof (data->ed_server_address)));
                break;
        case ILBD_REM_SERVER_FROM_GROUP:
                event->adt_ilb_remove_server.auth_used =
                    NET_ILB_CONFIG_AUTH;
                event->adt_ilb_remove_server.server_id =
                    data->ed_serverid;
                event->adt_ilb_remove_server.server_group = data->ed_sgroup;
                event->adt_ilb_remove_server.server_ipaddress_type =
                    data->ed_ipaddr_type;
                (void) memcpy(event->adt_ilb_remove_server.server_ipaddress,
                    data->ed_server_address,
                    (sizeof (data->ed_server_address)));
                break;
        case ILBD_CREATE_SERVERGROUP:
                event->adt_ilb_create_servergroup.auth_used =
                    NET_ILB_CONFIG_AUTH;
                event->adt_ilb_create_servergroup.server_group =
                    data->ed_sgroup;
                break;
        case ILBD_ADD_SERVER_TO_GROUP:
                event->adt_ilb_add_server.auth_used =
                    NET_ILB_CONFIG_AUTH;
                event->adt_ilb_add_server.server_ipaddress_type =
                    data->ed_ipaddr_type;
                (void) memcpy(event->adt_ilb_add_server.server_ipaddress,
                    data->ed_server_address,
                    (sizeof (data->ed_server_address)));
                event->adt_ilb_add_server.server_id =
                    data->ed_serverid;
                event->adt_ilb_add_server.server_group =
                    data->ed_sgroup;
                event->adt_ilb_add_server.server_minport =
                    ntohs(data->ed_minport);
                event->adt_ilb_add_server.server_maxport =
                    ntohs(data->ed_maxport);
                break;
        case ILBD_DESTROY_SERVERGROUP:
                event->adt_ilb_delete_servergroup.auth_used =
                    NET_ILB_CONFIG_AUTH;
                event->adt_ilb_delete_servergroup.server_group =
                    data->ed_sgroup;
                break;
        }

        /* Fill in success/failure */
        if (rc == ILB_STATUS_OK) {
                if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0) {
                        logerr("ilbd_audit_server_event:"
                            " adt_put_event failed");
                        exit(EXIT_FAILURE);
                }
        } else {
                audit_error = ilberror2auditerror(rc);
                if (adt_put_event(event, ADT_FAILURE, audit_error) != 0) {
                        logerr("ilbd_audit_server_event:"
                            " adt_put_event failed");
                        exit(EXIT_FAILURE);
                }
        }
        adt_free_event(event);
        (void) adt_end_session(ah);
}

ilb_status_t
ilbd_destroy_sg(const char *sg_name, const struct passwd *ps,
    ucred_t *ucredp)
{
        ilb_status_t    rc;
        ilbd_sg_t       *tmp_sg;
        audit_sg_event_data_t   audit_sg_data;

        (void) memset(&audit_sg_data, 0, sizeof (audit_sg_event_data_t));
        audit_sg_data.ed_sgroup = (char *)sg_name;

        rc = ilbd_check_client_config_auth(ps);
        if (rc != ILB_STATUS_OK) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_DESTROY_SERVERGROUP, rc, ucredp);
                return (rc);
        }

        tmp_sg = i_find_sg_byname(sg_name);
        if (tmp_sg == NULL) {
                logdebug("ilbd_destroy_sg: cannot find specified server"
                    " group %s", sg_name);
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_DESTROY_SERVERGROUP, ILB_STATUS_SGUNAVAIL, ucredp);
                return (ILB_STATUS_SGUNAVAIL);
        }

        /*
         * we only destroy SGs that don't have any rules associated with
         * them anymore.
         */
        if (list_head(&tmp_sg->isg_rulelist) != NULL) {
                logdebug("ilbd_destroy_sg: server group %s has rules"
                " associated with it and thus cannot be"
                    " removed", tmp_sg->isg_name);
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_DESTROY_SERVERGROUP, ILB_STATUS_SGINUSE, ucredp);
                return (ILB_STATUS_SGINUSE);
        }

        if (ps != NULL) {
                rc = i_ilbd_save_sg(tmp_sg, ILBD_SCF_DESTROY, NULL, NULL);
                if (rc != ILB_STATUS_OK) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_DESTROY_SERVERGROUP, rc, ucredp);
                        return (rc);
                }
        }
        i_ilbd_free_sg(tmp_sg);
        ilbd_audit_server_event(&audit_sg_data, ILBD_DESTROY_SERVERGROUP,
            rc, ucredp);
        return (rc);
}

/* ARGSUSED */
/*
 * Parameter ev_port is not used but has to have for read persistent configure
 * ilbd_create_sg(), ilbd_create_hc() and ilbd_create_rule() are callbacks
 * for ilbd_scf_instance_walk_pg() which requires the same signature.
 */
ilb_status_t
ilbd_create_sg(ilb_sg_info_t *sg, int ev_port, const struct passwd *ps,
    ucred_t *ucredp)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_sg_t       *d_sg;
        audit_sg_event_data_t   audit_sg_data;

        (void) memset(&audit_sg_data, 0, sizeof (audit_sg_event_data_t));
        audit_sg_data.ed_sgroup = sg->sg_name;

        if (ps != NULL) {
                rc = ilbd_check_client_config_auth(ps);
                if (rc != ILB_STATUS_OK) {
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_CREATE_SERVERGROUP, rc, ucredp);
                        return (rc);
                }
        }

        if (i_find_sg_byname(sg->sg_name) != NULL) {
                logdebug("ilbd_create_sg: server group %s already exists",
                    sg->sg_name);
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_CREATE_SERVERGROUP, ILB_STATUS_SGEXISTS, ucredp);
                return (ILB_STATUS_SGEXISTS);
        }

        d_sg = i_ilbd_alloc_sg(sg->sg_name);
        if (d_sg == NULL) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_CREATE_SERVERGROUP, ILB_STATUS_ENOMEM, ucredp);
                return (ILB_STATUS_ENOMEM);
        }

        /*
         * we've successfully created the sg in memory. Before we can
         * return "success", we need to reflect this in persistent
         * storage
         */
        if (ps != NULL) {
                rc = i_ilbd_save_sg(d_sg, ILBD_SCF_CREATE, NULL, NULL);
                if (rc != ILB_STATUS_OK) {
                        i_ilbd_free_sg(d_sg);
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_CREATE_SERVERGROUP, rc, ucredp);
                        return (rc);
                }
        }
        ilbd_audit_server_event(&audit_sg_data,
            ILBD_CREATE_SERVERGROUP, rc, ucredp);
        return (rc);
}

/*
 * This function checks whether tsrv should/can be inserted before lsrv
 * and does so if possible.
 * We keep the list in sorted order so we don't have to search it
 * in its entirety for overlap every time we insert a new server.
 * Return code:
 *      stop_found: don't continue searching because we found a place
 *      cont_search: continue with next element in the list
 *      fail_search: search failed (caller translates to ILB_STATUS_EEXIST)
 */
static srch_ind_t
i_test_and_insert(ilbd_srv_t *tsrv, ilbd_srv_t *lsrv, list_t *srvlist)
{
        struct in6_addr *t1, *l1;
        int             fnd;

        t1 = &tsrv->isv_addr;
        l1 = &lsrv->isv_addr;

        if ((fnd = ilb_cmp_in6_addr(t1, l1, NULL)) == 1)
                return (cont_search);   /* search can continue */

        if (fnd == 0) {
                logdebug("i_test_and_insert: specified server already exists");
                return (fail_search);
        }
        /* the list is kept in ascending order */
        list_insert_before(srvlist, lsrv, tsrv);
        return (stop_found);
}


/*
 * copy a server description [ip1,ip2,port1,port2,srvID,flags]
 */
#define COPY_SERVER(src, dest)                                  \
        (dest)->sgs_addr = (src)->sgs_addr;                     \
        (dest)->sgs_minport = (src)->sgs_minport;               \
        (dest)->sgs_maxport = (src)->sgs_maxport;               \
        (dest)->sgs_id = (src)->sgs_id;                         \
        (void) strlcpy((dest)->sgs_srvID, (src)->sgs_srvID,     \
            sizeof ((dest)->sgs_srvID));                        \
        (dest)->sgs_flags = (src)->sgs_flags

static ilb_status_t
i_add_srv2sg(ilbd_sg_t *dsg, ilb_sg_srv_t *srv, ilbd_srv_t **ret_srv)
{
        ilb_sg_srv_t    *n_sg_srv;
        list_t          *srvlist;
        srch_ind_t      search = not_searched;
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_srv_t      *nsrv, *lsrv;
        in_port_t       h_minport, h_maxport;

        nsrv = calloc(sizeof (*nsrv), 1);
        if (nsrv == NULL)
                return (ILB_STATUS_ENOMEM);
        n_sg_srv = &nsrv->isv_srv;
        COPY_SERVER(srv, n_sg_srv);

        /*
         * port info is in network byte order - we need host byte order
         * for comparisons purposes
         */
        h_minport = ntohs(n_sg_srv->sgs_minport);
        h_maxport = ntohs(n_sg_srv->sgs_maxport);
        if (h_minport != 0 && h_minport > h_maxport)
                n_sg_srv->sgs_maxport = n_sg_srv->sgs_minport;

        srvlist = &dsg->isg_srvlist;

        lsrv = list_head(srvlist);
        if (lsrv == NULL) {
                list_insert_head(srvlist, nsrv);
        } else {
                while (lsrv != NULL) {
                        search = i_test_and_insert(nsrv, lsrv,
                            srvlist);

                        if (search != cont_search)
                                break;
                        lsrv = list_next(srvlist, lsrv);

                        /* if reaches the end of list, insert to the tail */
                        if (search == cont_search && lsrv == NULL)
                                list_insert_tail(srvlist, nsrv);
                }
                if (search == fail_search)
                        rc = ILB_STATUS_EEXIST;
        }

        if (rc == ILB_STATUS_OK) {
                dsg->isg_srvcount++;
                *ret_srv = nsrv;
        } else {
                free(nsrv);
        }

        return (rc);
}

/*
 * Allocate a server ID.  The algorithm is simple.  Just check the ID array
 * of the server group and find an unused ID.  If *set_id is given, it
 * means that the ID is already allocated and the ID array needs to be
 * updated.  This is the case when ilbd reads from the persistent
 * configuration.
 */
static int32_t
i_ilbd_alloc_srvID(ilbd_sg_t *sg, int32_t *set_id)
{
        int32_t         id;
        int32_t         i;

        /* The server ID is already allocated, just update the ID array. */
        if (set_id != NULL) {
                assert(sg->isg_id_arr[*set_id] == 0);
                sg->isg_id_arr[*set_id] = 1;
                return (*set_id);
        }

        /* if we're "full up", give back something invalid */
        if (sg->isg_srvcount == MAX_SRVCOUNT)
                return (BAD_SRVID);

        i = sg->isg_max_id;
        for (id = 0; id < MAX_SRVCOUNT; id++) {
                if (sg->isg_id_arr[(id + i) % MAX_SRVCOUNT] == 0)
                        break;
        }

        sg->isg_max_id = (id + i) % MAX_SRVCOUNT;
        sg->isg_id_arr[sg->isg_max_id] = 1;
        return (sg->isg_max_id);
}

/*
 * Free a server ID by updating the server group's ID array.
 */
static void
i_ilbd_free_srvID(ilbd_sg_t *sg, int32_t id)
{
        assert(sg->isg_id_arr[id] == 1);
        sg->isg_id_arr[id] = 0;
}

/*
 * This function is called by ilbd_add_server_to_group() and
 * ilb_remove_server_group() to create a audit record for a
 * failed servicing of add-server/remove-server command
 */
static void
fill_audit_record(ilb_sg_info_t *sg, audit_sg_event_data_t *audit_sg_data,
    ilbd_cmd_t cmd, ilb_status_t rc, ucred_t *ucredp)
{
        ilb_sg_srv_t    *tsrv;
        int     i;

        for (i = 0; i < sg->sg_srvcount; i++) {
                tsrv = &sg->sg_servers[i];
                if (cmd == ILBD_ADD_SERVER_TO_GROUP)  {

                        audit_sg_data->ed_serverid = NULL;
                        if (IN6_IS_ADDR_V4MAPPED(&tsrv->sgs_addr)) {
                                audit_sg_data->ed_ipaddr_type = ADT_IPv4;
                                cvt_addr(audit_sg_data->ed_server_address,
                                    ADT_IPv4, tsrv->sgs_addr);
                        } else {
                                audit_sg_data->ed_ipaddr_type = ADT_IPv6;
                                cvt_addr(audit_sg_data->ed_server_address,
                                    ADT_IPv6, tsrv->sgs_addr);
                        }
                        audit_sg_data->ed_minport = tsrv->sgs_minport;
                        audit_sg_data->ed_maxport = tsrv->sgs_maxport;
                        audit_sg_data->ed_sgroup = sg->sg_name;
                } else if (cmd == ILBD_REM_SERVER_FROM_GROUP) {
                        audit_sg_data->ed_serverid = tsrv->sgs_srvID;
                        audit_sg_data->ed_sgroup = sg->sg_name;

                        audit_sg_data->ed_minport = 0;
                        audit_sg_data->ed_maxport = 0;
                }
                ilbd_audit_server_event(audit_sg_data, cmd, rc, ucredp);
        }
}

/*
 * the name(s) of the server(s) are encoded in the sg.
 */
ilb_status_t
ilbd_add_server_to_group(ilb_sg_info_t *sg_info, int ev_port,
    const struct passwd *ps, ucred_t *ucredp)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_sg_t       *tmp_sg;
        int             i, j;
        int32_t         new_id = BAD_SRVID;
        int32_t         af = AF_UNSPEC;
        ilbd_srv_t      *nsrv;
        ilb_sg_srv_t    *srv;
        audit_sg_event_data_t   audit_sg_data;

        if (ps != NULL) {
                rc = ilbd_check_client_config_auth(ps);
                if (rc != ILB_STATUS_OK) {
                        fill_audit_record(sg_info, &audit_sg_data,
                            ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                        return (rc);
                }
        }

        tmp_sg = i_find_sg_byname(sg_info->sg_name);
        if (tmp_sg == NULL) {
                logdebug("ilbd_add_server_to_group: server"
                    " group %s does not exist", sg_info->sg_name);
                fill_audit_record(sg_info, &audit_sg_data,
                    ILBD_ADD_SERVER_TO_GROUP, ILB_STATUS_ENOENT, ucredp);
                return (ILB_STATUS_ENOENT);
        }

        /*
         * we do the dance with address family below to make sure only
         * IP addresses in the same AF get into an SG; the first one to get
         * in sets the "tone"
         * if this is the first server to join a group, check whether
         * there's no mismatch with any *rules* already attached
         */
        if (tmp_sg->isg_srvcount > 0) {
                ilbd_srv_t *tsrv = list_head(&tmp_sg->isg_srvlist);

                af = GET_AF(&tsrv->isv_addr);
        } else {
                ilbd_rule_t     *irl = list_head(&tmp_sg->isg_rulelist);

                if (irl != NULL)
                        af = GET_AF(&irl->irl_vip);
        }

        for (i = 0; i < sg_info->sg_srvcount; i++) {
                srv = &sg_info->sg_servers[i];

                (void) memset(&audit_sg_data, 0, sizeof (audit_sg_data));
                if (IN6_IS_ADDR_V4MAPPED(&srv->sgs_addr)) {
                        audit_sg_data.ed_ipaddr_type = ADT_IPv4;
                        cvt_addr(audit_sg_data.ed_server_address, ADT_IPv4,
                            srv->sgs_addr);
                } else {
                        audit_sg_data.ed_ipaddr_type = ADT_IPv6;
                        cvt_addr(audit_sg_data.ed_server_address, ADT_IPv6,
                            srv->sgs_addr);
                }
                audit_sg_data.ed_minport = srv->sgs_minport;
                audit_sg_data.ed_maxport = srv->sgs_maxport;
                audit_sg_data.ed_sgroup = sg_info->sg_name;

                /* only test if we have sth to test against */
                if (af != AF_UNSPEC) {
                        int32_t sgs_af = GET_AF(&srv->sgs_addr);

                        if (af != sgs_af) {
                                logdebug("address family mismatch with previous"
                                    " hosts in servergroup or with rule");
                                rc = ILB_STATUS_MISMATCHH;
                                ilbd_audit_server_event(&audit_sg_data,
                                    ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                                goto rollback;
                        }
                }

                /*
                 * PS: NULL means daemon is loading configure from scf.
                 * ServerID is already assigned, just update the ID array.
                 */
                if (ps != NULL) {
                        new_id = i_ilbd_alloc_srvID(tmp_sg, NULL);
                        if (new_id == BAD_SRVID) {
                                logdebug("ilbd_add_server_to_group: server"
                                    "group %s is full, no more servers"
                                    " can be added", sg_info->sg_name);
                                rc = ILB_STATUS_SGFULL;
                                ilbd_audit_server_event(&audit_sg_data,
                                    ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                                goto rollback;
                        }
                        srv->sgs_id = new_id;
                } else {
                        new_id = i_ilbd_alloc_srvID(tmp_sg, &srv->sgs_id);
                }

                /*
                 * here we implement the requirement that server IDs start
                 * with a character that is not legal in hostnames - in our
                 * case, a "_" (underscore).
                 */
                (void) snprintf(srv->sgs_srvID,
                    sizeof (srv->sgs_srvID), "%c%s.%d", ILB_SRVID_PREFIX,
                    tmp_sg->isg_name, srv->sgs_id);
                audit_sg_data.ed_serverid = srv->sgs_srvID;

                /*
                 * Before we update the kernel rules by adding the server,
                 * we need to make checks and fail if any of the
                 * following is true:
                 *
                 * o if the server has single port and the servergroup
                 *   is associated to a DSR rule with a port range
                 * o if the server has a port range and the servergroup
                 *   is associated to a DSR rule with a port range and
                 *   the rule's min and max port does not exactly
                 *   match that of the server's.
                 * o if the the server has a port range and the servergroup
                 *   is associated to a NAT/Half-NAT rule with a port range
                 *   and the rule's port range size does not match that
                 *   of the server's.
                 * o if the rule has a fixed hc port, check that this port
                 *   is valid in the server's port specification.
                 */
                rc = i_check_srv2rules(&tmp_sg->isg_rulelist, srv);
                if (rc != ILB_STATUS_OK) {
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                        goto rollback;
                }

                if ((rc = i_add_srv2sg(tmp_sg, srv, &nsrv)) != ILB_STATUS_OK) {
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                        goto rollback;
                }

                rc = i_add_srv2krules(&tmp_sg->isg_rulelist, &nsrv->isv_srv,
                    ev_port);
                if (rc != ILB_STATUS_OK) {
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                        /*
                         * The failure may be due to the serverid being on
                         * hold in kernel for connection draining. But ilbd
                         * has no way of knowing that. So we are freeing up
                         * the serverid, and may run into the risk of
                         * having this failure again, if we choose this
                         * serverid  when processing the next add-server
                         * command for this servergroup, while connection
                         * draining is underway. We assume that the user
                         * will read the man page after they encounter
                         * this failure, and learn to not add any server
                         * to the servergroup until connection draining of
                         * all servers in the  servergroup is complete.
                         * XXX Need to revisit this when connection draining
                         * is reworked
                         */
                        list_remove(&tmp_sg->isg_srvlist, nsrv);
                        i_ilbd_free_srvID(tmp_sg, nsrv->isv_id);
                        free(nsrv);
                        tmp_sg->isg_srvcount--;
                        goto rollback;
                }
                if (ps != NULL) {
                        rc = ilbd_scf_add_srv(tmp_sg, nsrv);
                        if (rc != ILB_STATUS_OK) {
                                /*
                                 * The following should not fail since the
                                 * server is just added.  Just in case, we
                                 * pass in -1 as the event port to avoid
                                 * roll back in i_rem_srv_frm_krules() called
                                 * by i_delete_srv().
                                 */
                                ilbd_audit_server_event(&audit_sg_data,
                                    ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                                (void) i_delete_srv(tmp_sg, nsrv, -1);
                                break;
                        }
                }
        }

        if (rc == ILB_STATUS_OK) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_ADD_SERVER_TO_GROUP, rc, ucredp);
                return (rc);
        }

rollback:
        /*
         * If ilbd is initializing based on the SCF data and something fails,
         * the only choice is to transition the service to maintanence mode...
         */
        if (ps == NULL) {
                logerr("%s: failure during initialization -"
                    " entering maintenance mode", __func__);
                (void) smf_maintain_instance(ILB_FMRI, SMF_IMMEDIATE);
                return (rc);
        }

        /*
         * we need to roll back all servers previous to the one
         * that just caused the failure
         */
        for (j = i-1; j >= 0; j--) {
                srv = &sg_info->sg_servers[j];

                /* We should be able to find those servers just added. */
                nsrv = i_find_srv(&tmp_sg->isg_srvlist, srv, MODE_SRVID);
                assert(nsrv != NULL);
                (void) i_delete_srv(tmp_sg, nsrv, -1);
        }
        return (rc);
}

static srch_ind_t
i_match_srvID(ilb_sg_srv_t *sg_srv, ilbd_srv_t *lsrv)
{
        if (strncmp(sg_srv->sgs_srvID, lsrv->isv_srvID,
            sizeof (sg_srv->sgs_srvID)) == 0) {
                return (stop_found);
        }
        return (cont_search);
}

/*
 * Sanity check on a rule's port specification against all the servers'
 * specification in its associated server group.
 *
 * 1. If the health check's probe port (hcport) is specified.
 *    - if server port range is specified, check if hcport is inside
 *      the range
 *    - if no server port is specified (meaning the port range is the same as
 *      the rule's port range), check if hcport is inside the rule's range.
 *
 * 2. If a server has no port specification, there is no conflict.
 *
 * 3. If the rule's load balance mode is DSR, a server port specification must
 *    be exactly the same as the rule's.
 *
 * 4. In other modes (NAT and half-NAT), the server's port range must be
 *    the same as the rule's, unless it is doing port collapsing (the server's
 *    port range is only 1).
 */
ilb_status_t
ilbd_sg_check_rule_port(ilbd_sg_t *sg, ilb_rule_info_t *rl)
{
        ilbd_srv_t      *srv;
        in_port_t       r_minport, r_maxport;

        /* Don't allow adding a rule to a sg with no server, for now... */
        if (sg->isg_srvcount == 0)
                return (ILB_STATUS_SGEMPTY);

        r_minport = ntohs(rl->rl_minport);
        r_maxport = ntohs(rl->rl_maxport);

        for (srv = list_head(&sg->isg_srvlist); srv != NULL;
            srv = list_next(&sg->isg_srvlist, srv)) {
                in_port_t srv_minport, srv_maxport;
                int range;

                srv_minport = ntohs(srv->isv_minport);
                srv_maxport = ntohs(srv->isv_maxport);
                range = srv_maxport - srv_minport;

                /*
                 * If the rule has a specific probe port, check if that port is
                 * valid in all the servers' port specification.
                 */
                if (rl->rl_hcpflag == ILB_HCI_PROBE_FIX) {
                        in_port_t hcport = ntohs(rl->rl_hcport);

                        /* No server port specified. */
                        if (srv_minport == 0) {
                                if (hcport > r_maxport || hcport < r_minport) {
                                        return (ILB_STATUS_BADSG);
                                }
                        } else {
                                if (hcport > srv_maxport ||
                                    hcport < srv_minport) {
                                        return (ILB_STATUS_BADSG);
                                }
                        }
                }

                /*
                 * There is no server port specification, so there cannot be
                 * any conflict.
                 */
                if (srv_minport == 0)
                        continue;

                if (rl->rl_topo == ILB_TOPO_DSR) {
                        if (r_minport != srv_minport ||
                            r_maxport != srv_maxport) {
                                return (ILB_STATUS_BADSG);
                        }
                } else {
                        if ((range != r_maxport - r_minport) && range != 0)
                                return (ILB_STATUS_BADSG);
                }
        }

        return (ILB_STATUS_OK);
}

static srch_ind_t
i_match_srvIP(ilb_sg_srv_t *sg_srv, ilbd_srv_t *lsrv)
{
        if (IN6_ARE_ADDR_EQUAL(&sg_srv->sgs_addr, &lsrv->isv_addr))
                return (stop_found);
        return (cont_search);
}

static ilbd_srv_t *
i_find_srv(list_t *srvlist, ilb_sg_srv_t *sg_srv, int cmpmode)
{
        ilbd_srv_t      *tmp_srv;
        srch_ind_t      srch_res = cont_search;

        for (tmp_srv = list_head(srvlist); tmp_srv != NULL;
            tmp_srv = list_next(srvlist, tmp_srv)) {
                switch (cmpmode) {
                case MODE_ADDR:
                        srch_res = i_match_srvIP(sg_srv, tmp_srv);
                        break;
                case MODE_SRVID:
                        srch_res = i_match_srvID(sg_srv, tmp_srv);
                        break;
                }
                if (srch_res == stop_found)
                        break;
        }

        if (srch_res == stop_found)
                return (tmp_srv);
        return (NULL);
}

static ilb_status_t
i_delete_srv(ilbd_sg_t *sg, ilbd_srv_t *srv, int ev_port)
{
        ilb_status_t    rc;

        rc = i_rem_srv_frm_krules(&sg->isg_rulelist, &srv->isv_srv, ev_port);
        if (rc != ILB_STATUS_OK)
                return (rc);
        list_remove(&sg->isg_srvlist, srv);
        i_ilbd_free_srvID(sg, srv->isv_id);
        free(srv);
        sg->isg_srvcount--;
        return (ILB_STATUS_OK);
}

/*
 * some people argue that returning anything here is
 * useless - what *do* you do if you can't remove/destroy
 * something anyway?
 */
ilb_status_t
ilbd_rem_server_from_group(ilb_sg_info_t *sg_info, int ev_port,
    const struct passwd *ps, ucred_t *ucredp)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_sg_t       *tmp_sg;
        ilbd_srv_t      *srv, tmp_srv;
        ilb_sg_srv_t    *tsrv;
        audit_sg_event_data_t   audit_sg_data;

        rc = ilbd_check_client_config_auth(ps);
        if (rc != ILB_STATUS_OK) {
                fill_audit_record(sg_info, &audit_sg_data,
                    ILBD_REM_SERVER_FROM_GROUP, rc, ucredp);
                return (rc);
        }

        tmp_sg = i_find_sg_byname(sg_info->sg_name);
        if (tmp_sg == NULL) {
                logdebug("%s: server group %s\n does not exist", __func__,
                    sg_info->sg_name);
                fill_audit_record(sg_info, &audit_sg_data,
                    ILBD_REM_SERVER_FROM_GROUP, ILB_STATUS_SGUNAVAIL, ucredp);
                return (ILB_STATUS_SGUNAVAIL);
        }
        tsrv = &sg_info->sg_servers[0];
        audit_sg_data.ed_serverid = tsrv->sgs_srvID;
        audit_sg_data.ed_sgroup = sg_info->sg_name;

        assert(sg_info->sg_srvcount == 1);
        srv = i_find_srv(&tmp_sg->isg_srvlist, &sg_info->sg_servers[0],
            MODE_SRVID);
        if (srv == NULL) {
                logdebug("%s: cannot find server in server group %s", __func__,
                    sg_info->sg_name);
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_REM_SERVER_FROM_GROUP, ILB_STATUS_SRVUNAVAIL, ucredp);
                return (ILB_STATUS_SRVUNAVAIL);
        }
        tsrv = &srv->isv_srv;
        if (IN6_IS_ADDR_V4MAPPED(&tsrv->sgs_addr)) {
                audit_sg_data.ed_ipaddr_type = ADT_IPv4;
                cvt_addr(audit_sg_data.ed_server_address, ADT_IPv4,
                    tsrv->sgs_addr);
        } else {
                audit_sg_data.ed_ipaddr_type = ADT_IPv6;
                cvt_addr(audit_sg_data.ed_server_address, ADT_IPv6,
                    tsrv->sgs_addr);
        }
        /*
         * i_delete_srv frees srv, therefore we need to save
         * this information for ilbd_scf_del_srv
         */
        (void) memcpy(&tmp_srv, srv, sizeof (tmp_srv));

        rc = i_delete_srv(tmp_sg, srv, ev_port);
        if (rc != ILB_STATUS_OK) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_REM_SERVER_FROM_GROUP, rc, ucredp);
                return (rc);
        }

        if (ps != NULL) {
                if ((rc = ilbd_scf_del_srv(tmp_sg, &tmp_srv)) !=
                    ILB_STATUS_OK) {
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_REM_SERVER_FROM_GROUP, rc, ucredp);
                        logerr("%s: SCF update failed - entering maintenance"
                            " mode", __func__);
                        (void) smf_maintain_instance(ILB_FMRI, SMF_IMMEDIATE);
                }
        }
        ilbd_audit_server_event(&audit_sg_data,
            ILBD_REM_SERVER_FROM_GROUP, rc, ucredp);
        return (rc);
}

ilb_status_t
ilbd_retrieve_names(ilbd_cmd_t cmd, uint32_t *rbuf, size_t *rbufsz)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_namelist_t *nlist;
        size_t          tmp_rbufsz;

        tmp_rbufsz = *rbufsz;
        /* Set up the reply buffer.  rbufsz will be set to the new size. */
        ilbd_reply_ok(rbuf, rbufsz);

        /* Calculate how much space is left for holding name info. */
        *rbufsz += sizeof (ilbd_namelist_t);
        tmp_rbufsz -= *rbufsz;

        nlist = (ilbd_namelist_t *)&((ilb_comm_t *)rbuf)->ic_data;
        nlist->ilbl_count = 0;

        switch (cmd) {
        case ILBD_RETRIEVE_SG_NAMES: {
                ilbd_sg_t       *sg;

                for (sg = list_head(&ilbd_sg_hlist);
                    sg != NULL && tmp_rbufsz >= sizeof (ilbd_name_t);
                    sg = list_next(&ilbd_sg_hlist, sg),
                    tmp_rbufsz -= sizeof (ilbd_name_t)) {
                        (void) strlcpy(nlist->ilbl_name[nlist->ilbl_count++],
                            sg->isg_name, sizeof (ilbd_name_t));
                }
                break;
        }
        case ILBD_RETRIEVE_RULE_NAMES: {
                ilbd_rule_t     *irl;
                extern list_t   ilbd_rule_hlist;

                for (irl = list_head(&ilbd_rule_hlist);
                    irl != NULL && tmp_rbufsz >= sizeof (ilbd_name_t);
                    irl = list_next(&ilbd_rule_hlist, irl),
                    tmp_rbufsz -= sizeof (ilbd_name_t)) {
                        (void) strlcpy(nlist->ilbl_name[nlist->ilbl_count++],
                            irl->irl_name, sizeof (ilbd_name_t));
                }
                break;
        }
        case ILBD_RETRIEVE_HC_NAMES: {
                extern list_t   ilbd_hc_list;
                ilbd_hc_t       *hc;

                for (hc = list_head(&ilbd_hc_list);
                    hc != NULL && tmp_rbufsz >= sizeof (ilbd_name_t);
                    hc = list_next(&ilbd_hc_list, hc)) {
                        (void) strlcpy(nlist->ilbl_name[nlist->ilbl_count++],
                            hc->ihc_name, sizeof (ilbd_name_t));
                }
                break;
        }
        default:
                logdebug("ilbd_retrieve_names: unknown command");
                return (ILB_STATUS_INVAL_CMD);
        }

        *rbufsz += nlist->ilbl_count * sizeof (ilbd_name_t);
        return (rc);
}

ilb_status_t
ilbd_retrieve_sg_hosts(const char *sg_name, uint32_t *rbuf, size_t *rbufsz)
{
        ilbd_sg_t       *dsg;
        ilbd_srv_t      *dsrv;
        list_t          *srvlist;
        ilb_sg_info_t   *sg_info;
        size_t          tmp_rbufsz;

        dsg = i_find_sg_byname(sg_name);
        if (dsg == NULL) {
                logdebug("ilbd_retrieve_sg_hosts: server group"
                    " %s not found", sg_name);
                return (ILB_STATUS_SGUNAVAIL);
        }

        srvlist = &dsg->isg_srvlist;
        dsrv = list_head(srvlist);

        tmp_rbufsz = *rbufsz;
        ilbd_reply_ok(rbuf, rbufsz);

        /* Calculate the size to hold all the hosts info. */
        *rbufsz += sizeof (ilb_sg_info_t);
        tmp_rbufsz -= *rbufsz;

        sg_info = (ilb_sg_info_t *)&((ilb_comm_t *)rbuf)->ic_data;
        (void) strlcpy(sg_info->sg_name, sg_name, sizeof (sg_info->sg_name));
        sg_info->sg_srvcount = 0;

        while (dsrv != NULL && tmp_rbufsz >= sizeof (ilb_sg_srv_t)) {
                sg_info->sg_servers[sg_info->sg_srvcount++] = dsrv->isv_srv;
                dsrv = list_next(srvlist, dsrv);
                tmp_rbufsz -= sizeof (ilb_sg_srv_t);
        }
        *rbufsz += sg_info->sg_srvcount * sizeof (ilb_sg_srv_t);
        return (ILB_STATUS_OK);
}

/*
 * this mapping function works on the assumption that HC only is
 * active when a server is enabled.
 */
static ilb_cmd_t
i_srvcmd_d2k(ilbd_srv_status_ind_t dcmd)
{
        ilb_cmd_t       cmd;

        switch (dcmd) {
        case stat_enable_server:
        case stat_declare_srv_alive:
                cmd = ILB_ENABLE_SERVERS;
                break;
        case stat_disable_server:
        case stat_declare_srv_dead:
                cmd = ILB_DISABLE_SERVERS;
                break;
        }

        return (cmd);
}

ilb_status_t
ilbd_k_Xable_server(const struct in6_addr *addr, const char *rlname,
    ilbd_srv_status_ind_t cmd)
{
        ilb_status_t            rc;
        ilb_servers_cmd_t       kcmd;
        int                     e;

        kcmd.cmd = i_srvcmd_d2k(cmd);
        (void) strlcpy(kcmd.name, rlname, sizeof (kcmd.name));
        kcmd.num_servers = 1;

        kcmd.servers[0].addr = *addr;
        kcmd.servers[0].err = 0;

        rc = do_ioctl(&kcmd, 0);
        if (rc != ILB_STATUS_OK)
                return (rc);

        if ((e = kcmd.servers[0].err) != 0) {
                logdebug("ilbd_k_Xable_server: error %s occurred",
                    strerror(e));
                return (ilb_map_errno2ilbstat(e));
        }

        return (rc);
}

#define IS_SRV_ENABLED(s)       ILB_IS_SRV_ENABLED((s)->sgs_flags)
#define IS_SRV_DISABLED(s)      (!(IS_SRV_ENABLED(s)))

#define SET_SRV_ENABLED(s)      ILB_SET_ENABLED((s)->sgs_flags)
#define SET_SRV_DISABLED(s)     ILB_SET_DISABLED((s)->sgs_flags)

static ilb_status_t
ilbd_Xable_server(ilb_sg_info_t *sg, const struct passwd *ps,
    ilbd_srv_status_ind_t cmd, ucred_t *ucredp)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        ilbd_sg_t       *isg;
        ilbd_srv_t      *tmp_srv;
        ilb_sg_srv_t    *srv;
        ilbd_rule_t     *irl;
        char            *dot;
        int             scf_name_len = ILBD_MAX_NAME_LEN;
        int             scf_val_len = ILBD_MAX_VALUE_LEN;
        char            *prop_name = NULL;
        ilb_ip_addr_t   ipaddr;
        void            *addrptr;
        char            ipstr[INET6_ADDRSTRLEN], *valstr = NULL;
        int             ipver, vallen;
        char            sgname[ILB_NAMESZ];
        uint32_t        nflags;
        ilbd_srv_status_ind_t u_cmd;
        audit_sg_event_data_t   audit_sg_data;

        (void) memset(&audit_sg_data, 0, sizeof (audit_sg_data));

        /* we currently only implement a "list" of one */
        assert(sg->sg_srvcount == 1);

        srv = &sg->sg_servers[0];
        audit_sg_data.ed_serverid = srv->sgs_srvID;

        rc = ilbd_check_client_enable_auth(ps);
        if (rc != ILB_STATUS_OK) {
                ilbd_audit_server_event(&audit_sg_data,
                    ILBD_ENABLE_SERVER, rc, ucredp);
                return (rc);
        }

        if (srv->sgs_srvID[0] != ILB_SRVID_PREFIX) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER,
                            ILB_STATUS_EINVAL, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER,
                            ILB_STATUS_EINVAL, ucredp);
                        break;
                }
                return (ILB_STATUS_EINVAL);
        }

        /*
         * the following asserts that serverIDs are constructed
         * along the pattern "_"<SG name>"."<number>
         * so we look for the final "." to recreate the SG name.
         */
        (void) strlcpy(sgname, srv->sgs_srvID + 1, sizeof (sgname));
        dot = strrchr(sgname, (int)'.');
        if (dot == NULL) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER,
                            ILB_STATUS_EINVAL, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER,
                            ILB_STATUS_EINVAL, ucredp);
                        break;
                }
                return (ILB_STATUS_EINVAL);
        }

        /* make the non-sg_name part "invisible" */
        *dot = '\0';
        isg = i_find_sg_byname(sgname);
        if (isg == NULL) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER,
                            ILB_STATUS_ENOENT, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER,
                            ILB_STATUS_ENOENT, ucredp);
                        break;
                }
                return (ILB_STATUS_ENOENT);
        }

        tmp_srv = i_find_srv(&isg->isg_srvlist, srv, MODE_SRVID);
        if (tmp_srv == NULL) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER,
                            ILB_STATUS_ENOENT, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER,
                            ILB_STATUS_ENOENT, ucredp);
                        break;
                }
                return (ILB_STATUS_ENOENT);
        }

        /*
         * if server's servergroup is not associated with
         * a rule, do not enable it.
         */
        irl = list_head(&isg->isg_rulelist);
        if (irl == NULL) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER,
                            ILB_STATUS_INVAL_ENBSRVR, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER,
                            ILB_STATUS_INVAL_ENBSRVR, ucredp);
                        break;
                }
                return (ILB_STATUS_INVAL_ENBSRVR);
        }
        /* Fill in the server IP address for audit record */
        if (IN6_IS_ADDR_V4MAPPED(&tmp_srv->isv_addr)) {
                audit_sg_data.ed_ipaddr_type = ADT_IPv4;
                cvt_addr(audit_sg_data.ed_server_address, ADT_IPv4,
                    tmp_srv->isv_addr);
        } else {
                audit_sg_data.ed_ipaddr_type = ADT_IPv6;
                cvt_addr(audit_sg_data.ed_server_address, ADT_IPv6,
                    tmp_srv->isv_addr);
        }

        /*
         * We have found the server in memory, perform the following
         * tasks.
         *
         * 1. For every rule associated with this SG,
         *    - tell the kernel
         *    - tell the hc
         * 2. Update our internal state and persistent configuration
         *    if the new state is not the same as the old one.
         */
        /* 1. */
        for (; irl != NULL; irl = list_next(&isg->isg_rulelist, irl)) {
                rc = ilbd_k_Xable_server(&tmp_srv->isv_addr,
                    irl->irl_name, cmd);
                if (rc != ILB_STATUS_OK) {
                        switch (cmd) {
                        case stat_disable_server:
                                ilbd_audit_server_event(&audit_sg_data,
                                    ILBD_DISABLE_SERVER, rc, ucredp);
                                break;
                        case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER, rc, ucredp);
                        break;
                        }
                        goto rollback_rules;
                }
                if (!RULE_HAS_HC(irl))
                        continue;

                if (cmd == stat_disable_server) {
                        rc = ilbd_hc_disable_server(irl,
                            &tmp_srv->isv_srv);
                } else {
                        assert(cmd == stat_enable_server);
                        rc = ilbd_hc_enable_server(irl,
                            &tmp_srv->isv_srv);
                }
                if (rc != ILB_STATUS_OK) {
                        logdebug("ilbd_Xable_server: cannot toggle srv "
                            "timer, rc =%d, srv =%s%d\n", rc,
                            tmp_srv->isv_srvID,
                            tmp_srv->isv_id);
                }
        }

        /* 2. */
        if ((cmd == stat_disable_server &&
            IS_SRV_DISABLED(&tmp_srv->isv_srv)) ||
            (cmd == stat_enable_server &&
            IS_SRV_ENABLED(&tmp_srv->isv_srv))) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER, ILB_STATUS_OK, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER, ILB_STATUS_OK, ucredp);
                        break;
                }
                return (ILB_STATUS_OK);
        }

        nflags = tmp_srv->isv_flags;
        if (cmd == stat_enable_server)
                ILB_SET_ENABLED(nflags);
        else
                ILB_SET_DISABLED(nflags);

        IP_COPY_IMPL_2_CLI(&tmp_srv->isv_addr, &ipaddr);
        ipver = GET_AF(&tmp_srv->isv_addr);
        vallen = (ipver == AF_INET) ? INET_ADDRSTRLEN :
            INET6_ADDRSTRLEN;
        addrptr = (ipver == AF_INET) ? (void *)&ipaddr.ia_v4 :
            (void *)&ipaddr.ia_v6;
        if (inet_ntop(ipver, addrptr, ipstr, vallen) == NULL) {
                logerr("ilbd_Xable_server: failed transfer ip addr to"
                    " str");
                if (errno == ENOSPC)
                        rc = ILB_STATUS_ENOMEM;
                else
                        rc = ILB_STATUS_GENERIC;
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER, rc, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER, rc, ucredp);
                        break;
                }
                goto rollback_rules;
        }

        if ((prop_name = malloc(scf_name_len)) == NULL)
                return (ILB_STATUS_ENOMEM);
        if ((valstr = malloc(scf_val_len)) == NULL) {
                free(prop_name);
                return (ILB_STATUS_ENOMEM);
        }

        (void) snprintf(valstr, scf_val_len, "%s;%d;%d-%d;%d",
            ipstr, ipver,
            ntohs(tmp_srv->isv_minport),
            ntohs(tmp_srv->isv_maxport), nflags);
        (void) snprintf(prop_name, scf_name_len, "server%d",
            tmp_srv->isv_id);

        switch (cmd) {
        case stat_disable_server:
                rc = i_ilbd_save_sg(isg, ILBD_SCF_ENABLE_DISABLE,
                    prop_name, valstr);
                if (rc == ILB_STATUS_OK)
                        SET_SRV_DISABLED(&tmp_srv->isv_srv);
                break;
        case stat_enable_server:
                rc = i_ilbd_save_sg(isg, ILBD_SCF_ENABLE_DISABLE,
                    prop_name, valstr);
                if (rc == ILB_STATUS_OK)
                        SET_SRV_ENABLED(&tmp_srv->isv_srv);
                break;
        }
        free(prop_name);
        free(valstr);
        if (rc == ILB_STATUS_OK) {
                switch (cmd) {
                case stat_disable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_DISABLE_SERVER, ILB_STATUS_OK, ucredp);
                        break;
                case stat_enable_server:
                        ilbd_audit_server_event(&audit_sg_data,
                            ILBD_ENABLE_SERVER, ILB_STATUS_OK, ucredp);
                        break;
                }
                return (ILB_STATUS_OK);
        }

rollback_rules:
        if (cmd == stat_disable_server)
                u_cmd = stat_enable_server;
        else
                u_cmd = stat_disable_server;

        if (irl == NULL)
                irl = list_tail(&isg->isg_rulelist);
        else
                irl = list_prev(&isg->isg_rulelist, irl);

        for (; irl != NULL; irl = list_prev(&isg->isg_rulelist, irl)) {
                (void) ilbd_k_Xable_server(&tmp_srv->isv_addr,
                    irl->irl_name, u_cmd);
                if (!RULE_HAS_HC(irl))
                        continue;

                if (u_cmd == stat_disable_server)
                        (void) ilbd_hc_disable_server(irl, &tmp_srv->isv_srv);
                else
                        (void) ilbd_hc_enable_server(irl, &tmp_srv->isv_srv);
        }

        return (rc);
}

ilb_status_t
ilbd_disable_server(ilb_sg_info_t *sg, const struct passwd *ps,
    ucred_t *ucredp)
{
        return (ilbd_Xable_server(sg, ps, stat_disable_server, ucredp));
}

ilb_status_t
ilbd_enable_server(ilb_sg_info_t *sg, const struct passwd *ps,
    ucred_t *ucredp)
{
        return (ilbd_Xable_server(sg, ps, stat_enable_server, ucredp));
}

/*
 * fill in the srvID for the given IP address in the 0th server
 */
ilb_status_t
ilbd_address_to_srvID(ilb_sg_info_t *sg, uint32_t *rbuf, size_t *rbufsz)
{
        ilbd_srv_t      *tmp_srv;
        ilb_sg_srv_t    *tsrv;
        ilbd_sg_t       *tmp_sg;

        ilbd_reply_ok(rbuf, rbufsz);
        tsrv = (ilb_sg_srv_t *)&((ilb_comm_t *)rbuf)->ic_data;
        *rbufsz += sizeof (ilb_sg_srv_t);

        tmp_sg = i_find_sg_byname(sg->sg_name);
        if (tmp_sg == NULL)
                return (ILB_STATUS_SGUNAVAIL);
        tsrv->sgs_addr = sg->sg_servers[0].sgs_addr;

        tmp_srv = i_find_srv(&tmp_sg->isg_srvlist, tsrv, MODE_ADDR);
        if (tmp_srv == NULL)
                return (ILB_STATUS_ENOENT);

        (void) strlcpy(tsrv->sgs_srvID, tmp_srv->isv_srvID,
            sizeof (tsrv->sgs_srvID));

        return (ILB_STATUS_OK);
}

/*
 * fill in the address for the given serverID in the 0th server
 */
ilb_status_t
ilbd_srvID_to_address(ilb_sg_info_t *sg, uint32_t *rbuf, size_t *rbufsz)
{
        ilbd_srv_t      *tmp_srv;
        ilb_sg_srv_t    *tsrv;
        ilbd_sg_t       *tmp_sg;

        ilbd_reply_ok(rbuf, rbufsz);
        tsrv = (ilb_sg_srv_t *)&((ilb_comm_t *)rbuf)->ic_data;

        tmp_sg = i_find_sg_byname(sg->sg_name);
        if (tmp_sg == NULL)
                return (ILB_STATUS_SGUNAVAIL);
        (void) strlcpy(tsrv->sgs_srvID, sg->sg_servers[0].sgs_srvID,
            sizeof (tsrv->sgs_srvID));

        tmp_srv = i_find_srv(&tmp_sg->isg_srvlist, tsrv, MODE_SRVID);
        if (tmp_srv == NULL)
                return (ILB_STATUS_ENOENT);

        tsrv->sgs_addr = tmp_srv->isv_addr;
        *rbufsz += sizeof (ilb_sg_srv_t);

        return (ILB_STATUS_OK);
}

/*
 * Map ilb_status errors to similar errno values from errno.h or
 * adt_event.h to be used for audit record
 */
int
ilberror2auditerror(ilb_status_t rc)
{
        int audit_error;

        switch (rc) {
        case ILB_STATUS_CFGAUTH:
                audit_error = ADT_FAIL_VALUE_AUTH;
                break;
        case ILB_STATUS_ENOMEM:
                audit_error = ENOMEM;
                break;
        case ILB_STATUS_ENOENT:
        case ILB_STATUS_ENOHCINFO:
        case ILB_STATUS_INVAL_HCTESTTYPE:
        case ILB_STATUS_INVAL_CMD:
        case ILB_STATUS_DUP_RULE:
        case ILB_STATUS_ENORULE:
        case ILB_STATUS_SGUNAVAIL:
                audit_error = ENOENT;
                break;
        case ILB_STATUS_EINVAL:
        case ILB_STATUS_MISMATCHSG:
        case ILB_STATUS_MISMATCHH:
        case ILB_STATUS_BADSG:
        case ILB_STATUS_INVAL_SRVR:
        case ILB_STATUS_INVAL_ENBSRVR:
        case ILB_STATUS_BADPORT:
                audit_error = EINVAL;
                break;
        case ILB_STATUS_EEXIST:
        case ILB_STATUS_SGEXISTS:
                audit_error = EEXIST;
                break;
        case ILB_STATUS_EWOULDBLOCK:
                audit_error = EWOULDBLOCK;
                break;
        case ILB_STATUS_INPROGRESS:
                audit_error = EINPROGRESS;
                break;
        case ILB_STATUS_INTERNAL:
        case ILB_STATUS_CALLBACK:
        case ILB_STATUS_PERMIT:
        case ILB_STATUS_RULE_NO_HC:
                audit_error = ADT_FAIL_VALUE_PROGRAM;
                break;
        case ILB_STATUS_SOCKET:
                audit_error = ENOTSOCK;
                break;
        case ILB_STATUS_READ:
        case ILB_STATUS_WRITE:
                audit_error = ENOTCONN;
                break;
        case ILB_STATUS_SGINUSE:
                audit_error = EADDRINUSE;
                break;
        case ILB_STATUS_SEND:
                audit_error = ECOMM;
                break;
        case ILB_STATUS_SGFULL:
                audit_error = EOVERFLOW;
                break;
        case ILB_STATUS_NAMETOOLONG:
                audit_error = ENAMETOOLONG;
                break;
        case ILB_STATUS_SRVUNAVAIL:
                audit_error = EHOSTUNREACH;
                break;
        default:
                audit_error = ADT_FAIL_VALUE_UNKNOWN;
                break;
        }
        return (audit_error);
}