/*
 * 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.
 */

#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stddef.h>
#include <libilb_impl.h>
#include <libilb.h>

/*
 * Create a health check, returning a health check handle upon success.
 * Health check created will be recorded in persistent datastore.
 */
ilb_status_t
ilb_create_hc(ilb_handle_t h, const ilb_hc_info_t *hc)
{
        ilb_status_t    rc;
        ilb_comm_t      *ic;
        size_t          ic_sz;

        if (h == ILB_INVALID_HANDLE || hc == NULL || *hc->hci_name == '\0' ||
            hc->hci_timeout < 0 || hc->hci_count < 0 ||
            hc->hci_interval <= hc->hci_timeout * hc->hci_count)
                return (ILB_STATUS_EINVAL);

        if ((ic = i_ilb_alloc_req(ILBD_CREATE_HC, &ic_sz)) == NULL)
                return (ILB_STATUS_ENOMEM);

        (void) memcpy(&ic->ic_data, hc, sizeof (ilb_hc_info_t));

        rc = i_ilb_do_comm(h, ic, ic_sz, ic, &ic_sz);
        if (rc != ILB_STATUS_OK)
                goto out;

        if (ic->ic_cmd != ILBD_CMD_OK)
                rc = *(ilb_status_t *)&ic->ic_data;

out:
        free(ic);
        return (rc);
}

/*
 * Given a health check handle, destroy the corresponding health check.
 * Persistent datastore will be updated as well.
 */
ilb_status_t
ilb_destroy_hc(ilb_handle_t h, const char *hcname)
{
        ilb_status_t    rc;
        ilb_comm_t      *ic;
        size_t          ic_sz;

        if (h == ILB_INVALID_HANDLE || hcname == NULL || *hcname == '\0')
                return (ILB_STATUS_EINVAL);

        if ((ic = i_ilb_alloc_req(ILBD_DESTROY_HC, &ic_sz)) == NULL)
                return (ILB_STATUS_ENOMEM);

        (void) strlcpy((char *)&ic->ic_data, hcname, sizeof (ilbd_name_t));

        rc = i_ilb_do_comm(h, ic, ic_sz, ic, &ic_sz);
        if (rc != ILB_STATUS_OK)
                goto out;

        if (ic->ic_cmd != ILBD_CMD_OK)
                rc = *(ilb_status_t *)&ic->ic_data;

out:
        free(ic);
        return (rc);
}

/*
 * Given a health check name, get hc info associated with this handle
 */
ilb_status_t
ilb_get_hc_info(ilb_handle_t h, const char *name, ilb_hc_info_t *hcp)
{
        ilb_status_t    rc;
        ilb_comm_t      *ic, *rbuf;
        size_t          ic_sz, rbufsz;

        if (h == ILB_INVALID_HANDLE || name == NULL || hcp == NULL)
                return (ILB_STATUS_EINVAL);

        if ((ic = i_ilb_alloc_req(ILBD_GET_HC_INFO, &ic_sz)) == NULL)
                return (ILB_STATUS_ENOMEM);
        rbufsz = sizeof (ilb_comm_t) + sizeof (ilb_hc_info_t);
        if ((rbuf = malloc(rbufsz)) == NULL) {
                free(ic);
                return (ILB_STATUS_ENOMEM);
        }

        (void) strlcpy((char *)&ic->ic_data, name, sizeof (ilbd_name_t));

        rc = i_ilb_do_comm(h, ic, ic_sz, rbuf, &rbufsz);
        if (rc != ILB_STATUS_OK)
                goto out;

        if (rbuf->ic_cmd != ILBD_CMD_OK) {
                rc = *(ilb_status_t *)&rbuf->ic_data;
                goto out;
        }
        (void) memcpy(hcp, &rbuf->ic_data, sizeof (*hcp));

out:
        free(ic);
        free(rbuf);
        return (rc);
}

/*
 * Walk through all health checks, will need if we implement list-hc
 */
ilb_status_t
ilb_walk_hc(ilb_handle_t h, hc_walkerfunc_t func, void *arg)
{
        ilb_status_t    rc;
        ilb_hc_info_t   hc_info;
        ilbd_namelist_t *hc_names;
        ilb_comm_t      ic, *rbuf;
        size_t          rbufsz;
        int             i;

        rbufsz = ILBD_MSG_SIZE;
        if ((rbuf = malloc(rbufsz)) == NULL)
                return (ILB_STATUS_ENOMEM);
        ic.ic_cmd = ILBD_RETRIEVE_HC_NAMES;

        rc = i_ilb_do_comm(h, &ic, sizeof (ic), rbuf, &rbufsz);
        if (rc != ILB_STATUS_OK)
                goto out;
        if (rbuf->ic_cmd != ILBD_CMD_OK) {
                rc = *(ilb_status_t *)&rbuf->ic_data;
                goto out;
        }

        hc_names = (ilbd_namelist_t *)&rbuf->ic_data;
        for (i = 0; i < hc_names->ilbl_count; i++) {
                rc = ilb_get_hc_info(h, hc_names->ilbl_name[i], &hc_info);
                /*
                 * Since getting the list of hc names and getting the info
                 * of each of them are not atomic, some hc objects may have
                 * been deleted.  If this is the case, just skip them.
                 */
                if (rc == ILB_STATUS_ENOENT) {
                        rc = ILB_STATUS_OK;
                        continue;
                } else if (rc != ILB_STATUS_OK) {
                        break;
                }
                rc = func(h, &hc_info, arg);
        }

out:
        free(rbuf);
        return (rc);
}

static ilb_status_t
ilb_get_hc_srvs(ilb_handle_t h, const char *rulename, ilb_comm_t **rbuf,
    size_t *rbufsz)
{
        ilb_status_t    rc;
        ilb_comm_t      *ic, *tmp_rbuf;
        size_t          ic_sz;

        if ((ic = i_ilb_alloc_req(ILBD_GET_HC_SRVS, &ic_sz)) == NULL)
                return (ILB_STATUS_ENOMEM);
        *rbufsz = ILBD_MSG_SIZE;
        if ((tmp_rbuf = malloc(*rbufsz)) == NULL) {
                free(ic);
                return (ILB_STATUS_ENOMEM);
        }

        (void) strlcpy((char *)&ic->ic_data, rulename,
            sizeof (ilbd_name_t));

        rc = i_ilb_do_comm(h, ic, ic_sz, tmp_rbuf, rbufsz);
        if (rc != ILB_STATUS_OK)
                goto out;

        if (tmp_rbuf->ic_cmd == ILBD_CMD_OK) {
                *rbuf = tmp_rbuf;
                return (rc);
        }
        rc = *(ilb_status_t *)&tmp_rbuf->ic_data;
out:
        free(ic);
        free(tmp_rbuf);
        *rbuf = NULL;
        return (rc);
}

ilb_status_t
ilb_walk_hc_srvs(ilb_handle_t h, hc_srvwalkerfunc_t fn, const char *rulename,
    void *arg)
{
        ilb_status_t            rc;
        ilb_hc_rule_srv_t       *srvs;
        int                     i, j;
        ilb_comm_t              *rbuf;
        size_t                  rbufsz;

        if (rulename != NULL) {
                rc = ilb_get_hc_srvs(h, rulename, &rbuf, &rbufsz);
                if (rc != ILB_STATUS_OK)
                        return (rc);
                srvs = (ilb_hc_rule_srv_t *)&rbuf->ic_data;
                for (i = 0; i < srvs->rs_num_srvs; i++) {
                        rc = fn(h, &srvs->rs_srvs[i], arg);
                        if (rc != ILB_STATUS_OK)
                                break;
                }
                free(rbuf);
        } else {
                ilbd_namelist_t *names;
                ilb_comm_t      *srv_rbuf;
                size_t          srv_rbufsz;

                rc = i_ilb_retrieve_rule_names(h, &rbuf, &rbufsz);
                if (rc != ILB_STATUS_OK)
                        return (rc);
                names = (ilbd_namelist_t *)&rbuf->ic_data;

                for (i = 0; i < names->ilbl_count; i++) {
                        rc = ilb_get_hc_srvs(h, names->ilbl_name[i],
                            &srv_rbuf, &srv_rbufsz);

                        /* Not all rules have HC, so reset the error to OK. */
                        if (rc == ILB_STATUS_RULE_NO_HC) {
                                rc = ILB_STATUS_OK;
                                continue;
                        } else if (rc != ILB_STATUS_OK) {
                                break;
                        }

                        srvs = (ilb_hc_rule_srv_t *)&srv_rbuf->ic_data;
                        for (j = 0; j < srvs->rs_num_srvs; j++) {
                                rc = fn(h, &srvs->rs_srvs[j], arg);
                                if (rc != ILB_STATUS_OK)
                                        break;
                        }
                        free(srv_rbuf);
                }
                free(rbuf);
        }
        return (rc);
}