usr.sbin/ilbadm/ilbadm_hc.c

	ilbadm_hc.c revision dbed73cbda2229fd1aa6dc5743993cae7f0a7ee9
/*
 * 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 <sys/types.h>
#include <sys/socket.h>
#include <sys/list.h>
#include <netinet/in.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <ofmt.h>
#include <libilb.h>
#include "ilbadm.h"

extern int  optind, optopt, opterr;
extern char *optarg;

typedef struct hc_export_arg {
    FILE    *fp;
} hc_export_arg_t;

/* Maximum columns for printing hc output. */
#define SHOW_HC_COLS    80

/* OFMT call back to print out a hc server result field. */
static boolean_t print_hc_result(ofmt_arg_t *, char *, uint_t);

/* ID to indicate which field to be printed. */
enum hc_print_id {
    hc_of_rname, hc_of_hname, hc_of_sname, hc_of_status, hc_of_fail_cnt,
    hc_of_lasttime, hc_of_nexttime, hc_of_rtt,
    hc_of_name, hc_of_timeout, hc_of_count, hc_of_interval, hc_of_def_ping,
    hc_of_test
};

/*
 * Fields of a hc server result.  The sum of all fields' width is SHOW_HC_COLS.
 */
static ofmt_field_t hc_results[] = {
    {"RULENAME",    14, hc_of_rname,    print_hc_result},
    {"HCNAME",  14, hc_of_hname,    print_hc_result},
    {"SERVERID",    14, hc_of_sname,    print_hc_result},
    {"STATUS",  9,  hc_of_status,   print_hc_result},
    {"FAIL",    5,  hc_of_fail_cnt, print_hc_result},
    {"LAST",    9,  hc_of_lasttime, print_hc_result},
    {"NEXT",    9,  hc_of_nexttime, print_hc_result},
    {"RTT",     6,  hc_of_rtt,  print_hc_result},
    {NULL,      0,  0,      NULL}
};

/* OFMT call back to print out a hc info field. */
static boolean_t print_hc(ofmt_arg_t *, char *, uint_t);

/*
 * Fields of a hc info.  The sume of all fields' width is SHOW_HC_COLS.
 */
static ofmt_field_t hc_fields[] = {
    {"HCNAME",  14, hc_of_name, print_hc},
    {"TIMEOUT", 8,  hc_of_timeout,  print_hc},
    {"COUNT",   8,  hc_of_count,    print_hc},
    {"INTERVAL",    9,  hc_of_interval, print_hc},
    {"DEF_PING",    9,  hc_of_def_ping, print_hc},
    {"TEST",    32, hc_of_test, print_hc},
    {NULL,      0,  0,      NULL}
};

static boolean_t
print_hc(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
    enum hc_print_id id = of_arg->ofmt_id;
    ilb_hc_info_t *info = (ilb_hc_info_t *)of_arg->ofmt_cbarg;

    switch (id) {
    case hc_of_name:
        (void) strlcpy(buf, info->hci_name, bufsize);
        break;
    case hc_of_timeout:
        (void) snprintf(buf, bufsize, "%d", info->hci_timeout);
        break;
    case hc_of_count:
        (void) snprintf(buf, bufsize, "%d", info->hci_count);
        break;
    case hc_of_interval:
        (void) snprintf(buf, bufsize, "%d", info->hci_interval);
        break;
    case hc_of_def_ping:
        (void) snprintf(buf, bufsize, "%c",
            info->hci_def_ping ? 'Y' : 'N');
        break;
    case hc_of_test:
        (void) snprintf(buf, bufsize, "%s", info->hci_test);
        break;
    }
    return (B_TRUE);
}

/* Call back to ilb_walk_hc(). */
/* ARGSUSED */
static ilb_status_t
ilbadm_print_hc(ilb_handle_t h, ilb_hc_info_t *hc_info, void *arg)
{
    ofmt_handle_t   ofmt_h = arg;

    ofmt_print(ofmt_h, hc_info);
    return (ILB_STATUS_OK);
}

/*
 * Print out health check objects given their name.
 * Or print out all health check objects if no name given.
 */
/* ARGSUSED */
ilbadm_status_t
ilbadm_show_hc(int argc, char *argv[])
{
    ilb_handle_t    h = ILB_INVALID_HANDLE;
    ilb_status_t    rclib;
    ofmt_handle_t   ofmt_h;
    ofmt_status_t   ofmt_ret;

    if ((ofmt_ret = ofmt_open("all", hc_fields, 0, SHOW_HC_COLS,
        &ofmt_h)) != OFMT_SUCCESS) {
        char err_buf[SHOW_HC_COLS];

        ilbadm_err(gettext("ofmt_open failed: %s"),
            ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
        return (ILBADM_LIBERR);
    }
    rclib = ilb_open(&h);
    if (rclib != ILB_STATUS_OK)
        goto out;

    if (argc == 1) {
        rclib = ilb_walk_hc(h, ilbadm_print_hc, ofmt_h);
    } else {
        ilb_hc_info_t hc_info;
        int i;

        for (i = 1; i < argc; i++) {
            rclib = ilb_get_hc_info(h, argv[i], &hc_info);
            if (rclib == ILB_STATUS_OK)
                ofmt_print(ofmt_h, &hc_info);
            else
                break;
        }
    }
out:
    ofmt_close(ofmt_h);

    if (h != ILB_INVALID_HANDLE)
        (void) ilb_close(h);

    if (rclib != ILB_STATUS_OK) {
        ilbadm_err(ilb_errstr(rclib));
        return (ILBADM_LIBERR);
    }

    return (ILBADM_OK);
}

static boolean_t
print_hc_result(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
    enum hc_print_id id = of_arg->ofmt_id;
    ilb_hc_srv_t *srv = (ilb_hc_srv_t *)of_arg->ofmt_cbarg;
    struct tm tv;

    switch (id) {
    case hc_of_rname:
        (void) strlcpy(buf, srv->hcs_rule_name, bufsize);
        break;
    case hc_of_hname:
        (void) strlcpy(buf, srv->hcs_hc_name, bufsize);
        break;
    case hc_of_sname:
        (void) strlcpy(buf, srv->hcs_ID, bufsize);
        break;
    case hc_of_status:
        switch (srv->hcs_status) {
        case ILB_HCS_UNINIT:
            (void) strlcpy(buf, "un-init", bufsize);
            break;
        case ILB_HCS_UNREACH:
            (void) strlcpy(buf, "unreach", bufsize);
            break;
        case ILB_HCS_ALIVE:
            (void) strlcpy(buf, "alive", bufsize);
            break;
        case ILB_HCS_DEAD:
            (void) strlcpy(buf, "dead", bufsize);
            break;
        case ILB_HCS_DISABLED:
            (void) strlcpy(buf, "disabled", bufsize);
            break;
        }
        break;
    case hc_of_fail_cnt:
        (void) snprintf(buf, bufsize, "%u", srv->hcs_fail_cnt);
        break;
    case hc_of_lasttime:
        if (localtime_r(&srv->hcs_lasttime, &tv) == NULL)
            return (B_FALSE);
        (void) snprintf(buf, bufsize, "%02d:%02d:%02d", tv.tm_hour,
            tv.tm_min, tv.tm_sec);
        break;
    case hc_of_nexttime:
        if (srv->hcs_status == ILB_HCS_DISABLED)
            break;
        if (localtime_r(&srv->hcs_nexttime, &tv) == NULL)
            return (B_FALSE);
        (void) snprintf(buf, bufsize, "%02d:%02d:%02d", tv.tm_hour,
            tv.tm_min, tv.tm_sec);
        break;
    case hc_of_rtt:
        (void) snprintf(buf, bufsize, "%u", srv->hcs_rtt);
        break;
    }
    return (B_TRUE);
}

/* Call back to ilbd_walk_hc_srvs(). */
/* ARGSUSED */
static ilb_status_t
ilbadm_print_hc_result(ilb_handle_t h, ilb_hc_srv_t *srv, void *arg)
{
    ofmt_handle_t   ofmt_h = arg;

    ofmt_print(ofmt_h, srv);
    return (ILB_STATUS_OK);
}

/*
 * Output hc result of a specified rule or all rules.
 */
ilbadm_status_t
ilbadm_show_hc_result(int argc, char *argv[])
{
    ilb_handle_t    h = ILB_INVALID_HANDLE;
    ilb_status_t    rclib = ILB_STATUS_OK;
    int     i;
    ofmt_handle_t   ofmt_h;
    ofmt_status_t   ofmt_ret;

    /* ilbadm show-hc-result [rule-name] */
    if (argc < 1) {
        ilbadm_err(gettext("usage: ilbadm show-hc-result"
            " [rule-name]"));
        return (ILBADM_LIBERR);
    }

    if ((ofmt_ret = ofmt_open("all", hc_results, 0, SHOW_HC_COLS,
        &ofmt_h)) != OFMT_SUCCESS) {
        char err_buf[SHOW_HC_COLS];

        ilbadm_err(gettext("ofmt_open failed: %s"),
            ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
        return (ILBADM_LIBERR);
    }

    rclib = ilb_open(&h);
    if (rclib != ILB_STATUS_OK)
        goto out;

    /* If no rule name is given, show results for all rules. */
    if (argc == 1) {
        rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result, NULL,
            ofmt_h);
    } else {
        for (i = 1; i < argc; i++) {
            rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result,
                argv[i], ofmt_h);
            if (rclib != ILB_STATUS_OK)
                break;
        }
    }
out:
    ofmt_close(ofmt_h);

    if (h != ILB_INVALID_HANDLE)
        (void) ilb_close(h);

    if (rclib != ILB_STATUS_OK) {
        ilbadm_err(ilb_errstr(rclib));
        return (ILBADM_LIBERR);
    }
    return (ILBADM_OK);
}

#define ILBADM_DEF_HC_COUNT 3
#define ILBADM_DEF_HC_INTERVAL  30  /* in sec */
#define ILBADM_DEF_HC_TIMEOUT   5   /* in sec */

static ilbadm_key_name_t hc_parse_keys[] = {
    {ILB_KEY_HC_TEST, "hc-test", "hc-test"},
    {ILB_KEY_HC_COUNT, "hc-count", "hc-count"},
    {ILB_KEY_HC_TIMEOUT, "hc-timeout", "hc-tout"},
    {ILB_KEY_HC_INTERVAL, "hc-interval", "hc-intl"},
    {ILB_KEY_BAD, "", ""}
};

static ilbadm_status_t
ilbadm_hc_parse_arg(char *arg, ilb_hc_info_t *hc)
{
    ilbadm_status_t ret;

    /* set default value for count, interval, timeout */
    hc->hci_count = ILBADM_DEF_HC_COUNT;
    hc->hci_interval = ILBADM_DEF_HC_INTERVAL;
    hc->hci_timeout = ILBADM_DEF_HC_TIMEOUT;
    hc->hci_test[0] = '\0';

    ret = i_parse_optstring(arg, hc, hc_parse_keys, 0, NULL);
    if (ret != ILBADM_OK && ret != ILBADM_LIBERR) {
        ilbadm_err(ilbadm_errstr(ret));
        return (ILBADM_LIBERR);
    }
    if (hc->hci_test[0] == '\0' && ret != ILBADM_LIBERR) {
        ilbadm_err("hc-test: missing");
        return (ILBADM_LIBERR);
    }
    return (ret);
}

/* ARGSUSED */
ilbadm_status_t
ilbadm_create_hc(int argc, char *argv[])
{
    ilb_handle_t    h = ILB_INVALID_HANDLE;
    ilb_hc_info_t   hc_info;
    ilbadm_status_t ret = ILBADM_OK;
    ilb_status_t    rclib;
    char        c;


    hc_info.hci_def_ping = B_TRUE;
    while ((c = getopt(argc, argv, ":h:n")) != -1) {
        if (c == 'h') {
            ret = ilbadm_hc_parse_arg(optarg, &hc_info);
            if (ret != ILBADM_OK)
                return (ret);
        } else if (c == 'n') {
            hc_info.hci_def_ping = B_FALSE;
        } else {
            ilbadm_err(gettext("bad argument %c"), c);
            return (ILBADM_LIBERR);
        }
    }

    if (optind >= argc) {
        ilbadm_err(gettext("usage: ilbadm"
            " create-healthcheck [-n] -h"
            " hc-test=val[,hc-timeout=val][,hc-count=va]"
            "[,hc-interval=val]  hc-name"));
        return (ILBADM_FAIL);
    }

    if (strlen(argv[optind]) > ILBD_NAMESZ - 1) {
        ilbadm_err(gettext("health check object name %s is too long - "
            "must not exceed %d chars"), argv[optind],
            ILBD_NAMESZ - 1);
        return (ILBADM_FAIL);
    }

    if (((strcasecmp(hc_info.hci_test, ILB_HC_STR_UDP) == 0) ||
        (strcasecmp(hc_info.hci_test, ILB_HC_STR_PING) == 0)) &&
        !(hc_info.hci_def_ping)) {
        ilbadm_err(gettext("cannot disable default PING"
            " for this test"));
        return (ILBADM_LIBERR);
    }

    rclib = ilb_open(&h);
    if (rclib != ILB_STATUS_OK)
        goto out;

    (void) strlcpy(hc_info.hci_name, argv[optind],
        sizeof (hc_info.hci_name));
    rclib = ilb_create_hc(h, &hc_info);
out:
    if (h != ILB_INVALID_HANDLE)
        (void) ilb_close(h);

    if (rclib != ILB_STATUS_OK) {
        ilbadm_err(ilb_errstr(rclib));
        ret = ILBADM_LIBERR;
    }
    return (ret);
}

ilbadm_status_t
ilbadm_destroy_hc(int argc, char *argv[])
{
    ilb_handle_t    h = ILB_INVALID_HANDLE;
    ilb_status_t    rclib;
    ilbadm_status_t ret = ILBADM_OK;
    int     i;

    if (argc < 2) {
        ilbadm_err(gettext("usage: ilbadm"
            " delete-healthcheck hc-name ..."));
        return (ILBADM_LIBERR);
    }

    rclib = ilb_open(&h);
    if (rclib != ILB_STATUS_OK)
        goto out;

    for (i = 1; i < argc; i++) {
        rclib = ilb_destroy_hc(h, argv[i]);
        if (rclib != ILB_STATUS_OK)
            break;
    }
out:
    if (h != ILB_INVALID_HANDLE)
        (void) ilb_close(h);

    if (rclib != ILB_STATUS_OK) {
        ilbadm_err(ilb_errstr(rclib));
        ret = ILBADM_LIBERR;
    }
    return (ret);
}

/*
 * Since this function is used by libilb function, it
 * must return libilb errors
 */
/* ARGSUSED */
ilb_status_t
ilbadm_export_hcinfo(ilb_handle_t h, ilb_hc_info_t *hc_info, void *arg)
{
    FILE        *fp = ((hc_export_arg_t *)arg)->fp;
    int     count = 0;
    int     ret;

    /*
     * a test name "PING" implies "no default ping", so we only
     * print -n if the test is NOT "PING"
     */
    if (hc_info->hci_def_ping == B_FALSE &&
        strncasecmp(hc_info->hci_test, "PING", 5) != 0)
        (void) fprintf(fp, "create-healthcheck -n -h ");
    else
        (void) fprintf(fp, "create-healthcheck -h ");

    if (*hc_info->hci_test != '\0') {
        (void) fprintf(fp, "hc-test=%s", hc_info->hci_test);
        count++;
    }
    if (hc_info->hci_timeout != 0) {
        if (count++ > 0)
            (void) fprintf(fp, ",");
        (void) fprintf(fp, "hc-timeout=%d", hc_info->hci_timeout);
    }
    if (hc_info->hci_count != 0) {
        if (count++ > 0)
            (void) fprintf(fp, ",");
        (void) fprintf(fp, "hc-count=%d", hc_info->hci_count);
    }
    if (hc_info->hci_interval != 0) {
        if (count > 0)
            (void) fprintf(fp, ",");
        (void) fprintf(fp, "hc-interval=%d", hc_info->hci_interval);
    }

    /*
     * if any of the above writes fails, then, we assume, so will
     * this one; so it's sufficient to test once
     */
    ret = fprintf(fp, " %s\n", hc_info->hci_name);
    if (ret < 0)
        goto out_fail;
    ret = fflush(fp);

out_fail:
    if (ret < 0)
        return (ILB_STATUS_WRITE);
    return (ILB_STATUS_OK);
}

ilbadm_status_t
ilbadm_export_hc(ilb_handle_t h, FILE *fp)
{
    ilb_status_t    rclib;
    ilbadm_status_t ret = ILBADM_OK;
    hc_export_arg_t arg;

    arg.fp = fp;
    rclib = ilb_walk_hc(h, ilbadm_export_hcinfo, (void *)&arg);
    if (rclib != ILB_STATUS_OK) {
        ilbadm_err(ilb_errstr(rclib));
        ret = ILBADM_LIBERR;
    }
    return (ret);
}