usr/src/cmd/cmd-inet/usr.sbin/ilbadm/ilbadm_hc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <sys/list.h>
  30 #include <netinet/in.h>
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <strings.h>
  35 #include <errno.h>
  36 #include <ofmt.h>
  37 #include <libilb.h>
  38 #include "ilbadm.h"
  39
  40 extern int      optind, optopt, opterr;
  41 extern char     *optarg;
  42
  43 typedef struct hc_export_arg {
  44         FILE    *fp;
  45 } hc_export_arg_t;
  46
  47 /* Maximum columns for printing hc output. */
  48 #define SHOW_HC_COLS    80
  49
  50 /* OFMT call back to print out a hc server result field. */
  51 static boolean_t print_hc_result(ofmt_arg_t *, char *, uint_t);
  52
  53 /* ID to indicate which field to be printed. */
  54 enum hc_print_id {
  55         hc_of_rname, hc_of_hname, hc_of_sname, hc_of_status, hc_of_fail_cnt,
  56         hc_of_lasttime, hc_of_nexttime, hc_of_rtt,
  57         hc_of_name, hc_of_timeout, hc_of_count, hc_of_interval, hc_of_def_ping,
  58         hc_of_test
  59 };
  60
  61 /*
  62  * Fields of a hc server result.  The sum of all fields' width is SHOW_HC_COLS.
  63  */
  64 static ofmt_field_t hc_results[] = {
  65         {"RULENAME",    14,     hc_of_rname,    print_hc_result},
  66         {"HCNAME",      14,     hc_of_hname,    print_hc_result},
  67         {"SERVERID",    14,     hc_of_sname,    print_hc_result},
  68         {"STATUS",      9,      hc_of_status,   print_hc_result},
  69         {"FAIL",        5,      hc_of_fail_cnt, print_hc_result},
  70         {"LAST",        9,      hc_of_lasttime, print_hc_result},
  71         {"NEXT",        9,      hc_of_nexttime, print_hc_result},
  72         {"RTT",         6,      hc_of_rtt,      print_hc_result},
  73         {NULL,          0,      0,              NULL}
  74 };
  75
  76 /* OFMT call back to print out a hc info field. */
  77 static boolean_t print_hc(ofmt_arg_t *, char *, uint_t);
  78
  79 /*
  80  * Fields of a hc info.  The sume of all fields' width is SHOW_HC_COLS.
  81  */
  82 static ofmt_field_t hc_fields[] = {
  83         {"HCNAME",      14,     hc_of_name,     print_hc},
  84         {"TIMEOUT",     8,      hc_of_timeout,  print_hc},
  85         {"COUNT",       8,      hc_of_count,    print_hc},
  86         {"INTERVAL",    9,      hc_of_interval, print_hc},
  87         {"DEF_PING",    9,      hc_of_def_ping, print_hc},
  88         {"TEST",        32,     hc_of_test,     print_hc},
  89         {NULL,          0,      0,              NULL}
  90 };
  91
  92 static boolean_t
  93 print_hc(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
  94 {
  95         enum hc_print_id id = of_arg->ofmt_id;
  96         ilb_hc_info_t *info = (ilb_hc_info_t *)of_arg->ofmt_cbarg;
  97
  98         switch (id) {
  99         case hc_of_name:
 100                 (void) strlcpy(buf, info->hci_name, bufsize);
 101                 break;
 102         case hc_of_timeout:
 103                 (void) snprintf(buf, bufsize, "%d", info->hci_timeout);
 104                 break;
 105         case hc_of_count:
 106                 (void) snprintf(buf, bufsize, "%d", info->hci_count);
 107                 break;
 108         case hc_of_interval:
 109                 (void) snprintf(buf, bufsize, "%d", info->hci_interval);
 110                 break;
 111         case hc_of_def_ping:
 112                 (void) snprintf(buf, bufsize, "%c",
 113                     info->hci_def_ping ? 'Y' : 'N');
 114                 break;
 115         case hc_of_test:
 116                 (void) snprintf(buf, bufsize, "%s", info->hci_test);
 117                 break;
 118         }
 119         return (B_TRUE);
 120 }
 121
 122 /* Call back to ilb_walk_hc(). */
 123 /* ARGSUSED */
 124 static ilb_status_t
 125 ilbadm_print_hc(ilb_handle_t h, ilb_hc_info_t *hc_info, void *arg)
 126 {
 127         ofmt_handle_t   ofmt_h = arg;
 128
 129         ofmt_print(ofmt_h, hc_info);
 130         return (ILB_STATUS_OK);
 131 }
 132
 133 /*
 134  * Print out health check objects given their name.
 135  * Or print out all health check objects if no name given.
 136  */
 137 /* ARGSUSED */
 138 ilbadm_status_t
 139 ilbadm_show_hc(int argc, char *argv[])
 140 {
 141         ilb_handle_t    h = ILB_INVALID_HANDLE;
 142         ilb_status_t    rclib;
 143         ofmt_handle_t   ofmt_h;
 144         ofmt_status_t   ofmt_ret;
 145
 146         if ((ofmt_ret = ofmt_open("all", hc_fields, 0, SHOW_HC_COLS,
 147             &ofmt_h)) != OFMT_SUCCESS) {
 148                 char err_buf[SHOW_HC_COLS];
 149
 150                 ilbadm_err(gettext("ofmt_open failed: %s"),
 151                     ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
 152                 return (ILBADM_LIBERR);
 153         }
 154         rclib = ilb_open(&h);
 155         if (rclib != ILB_STATUS_OK)
 156                 goto out;
 157
 158         if (argc == 1) {
 159                 rclib = ilb_walk_hc(h, ilbadm_print_hc, ofmt_h);
 160         } else {
 161                 ilb_hc_info_t hc_info;
 162                 int i;
 163
 164                 for (i = 1; i < argc; i++) {
 165                         rclib = ilb_get_hc_info(h, argv[i], &hc_info);
 166                         if (rclib == ILB_STATUS_OK)
 167                                 ofmt_print(ofmt_h, &hc_info);
 168                         else
 169                                 break;
 170                 }
 171         }
 172 out:
 173         ofmt_close(ofmt_h);
 174
 175         if (h != ILB_INVALID_HANDLE)
 176                 (void) ilb_close(h);
 177
 178         if (rclib != ILB_STATUS_OK) {
 179                 ilbadm_err(ilb_errstr(rclib));
 180                 return (ILBADM_LIBERR);
 181         }
 182
 183         return (ILBADM_OK);
 184 }
 185
 186 static boolean_t
 187 print_hc_result(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
 188 {
 189         enum hc_print_id id = of_arg->ofmt_id;
 190         ilb_hc_srv_t *srv = (ilb_hc_srv_t *)of_arg->ofmt_cbarg;
 191         struct tm tv;
 192
 193         switch (id) {
 194         case hc_of_rname:
 195                 (void) strlcpy(buf, srv->hcs_rule_name, bufsize);
 196                 break;
 197         case hc_of_hname:
 198                 (void) strlcpy(buf, srv->hcs_hc_name, bufsize);
 199                 break;
 200         case hc_of_sname:
 201                 (void) strlcpy(buf, srv->hcs_ID, bufsize);
 202                 break;
 203         case hc_of_status:
 204                 switch (srv->hcs_status) {
 205                 case ILB_HCS_UNINIT:
 206                         (void) strlcpy(buf, "un-init", bufsize);
 207                         break;
 208                 case ILB_HCS_UNREACH:
 209                         (void) strlcpy(buf, "unreach", bufsize);
 210                         break;
 211                 case ILB_HCS_ALIVE:
 212                         (void) strlcpy(buf, "alive", bufsize);
 213                         break;
 214                 case ILB_HCS_DEAD:
 215                         (void) strlcpy(buf, "dead", bufsize);
 216                         break;
 217                 case ILB_HCS_DISABLED:
 218                         (void) strlcpy(buf, "disabled", bufsize);
 219                         break;
 220                 }
 221                 break;
 222         case hc_of_fail_cnt:
 223                 (void) snprintf(buf, bufsize, "%u", srv->hcs_fail_cnt);
 224                 break;
 225         case hc_of_lasttime:
 226                 if (localtime_r(&srv->hcs_lasttime, &tv) == NULL)
 227                         return (B_FALSE);
 228                 (void) snprintf(buf, bufsize, "%02d:%02d:%02d", tv.tm_hour,
 229                     tv.tm_min, tv.tm_sec);
 230                 break;
 231         case hc_of_nexttime:
 232                 if (srv->hcs_status == ILB_HCS_DISABLED)
 233                         break;
 234                 if (localtime_r(&srv->hcs_nexttime, &tv) == NULL)
 235                         return (B_FALSE);
 236                 (void) snprintf(buf, bufsize, "%02d:%02d:%02d", tv.tm_hour,
 237                     tv.tm_min, tv.tm_sec);
 238                 break;
 239         case hc_of_rtt:
 240                 (void) snprintf(buf, bufsize, "%u", srv->hcs_rtt);
 241                 break;
 242         }
 243         return (B_TRUE);
 244 }
 245
 246 /* Call back to ilbd_walk_hc_srvs(). */
 247 /* ARGSUSED */
 248 static ilb_status_t
 249 ilbadm_print_hc_result(ilb_handle_t h, ilb_hc_srv_t *srv, void *arg)
 250 {
 251         ofmt_handle_t   ofmt_h = arg;
 252
 253         ofmt_print(ofmt_h, srv);
 254         return (ILB_STATUS_OK);
 255 }
 256
 257 /*
 258  * Output hc result of a specified rule or all rules.
 259  */
 260 ilbadm_status_t
 261 ilbadm_show_hc_result(int argc, char *argv[])
 262 {
 263         ilb_handle_t    h = ILB_INVALID_HANDLE;
 264         ilb_status_t    rclib = ILB_STATUS_OK;
 265         int             i;
 266         ofmt_handle_t   ofmt_h;
 267         ofmt_status_t   ofmt_ret;
 268
 269         /* ilbadm show-hc-result [rule-name] */
 270         if (argc < 1) {
 271                 ilbadm_err(gettext("usage: ilbadm show-hc-result"
 272                     " [rule-name]"));
 273                 return (ILBADM_LIBERR);
 274         }
 275
 276         if ((ofmt_ret = ofmt_open("all", hc_results, 0, SHOW_HC_COLS,
 277             &ofmt_h)) != OFMT_SUCCESS) {
 278                 char err_buf[SHOW_HC_COLS];
 279
 280                 ilbadm_err(gettext("ofmt_open failed: %s"),
 281                     ofmt_strerror(ofmt_h, ofmt_ret, err_buf, SHOW_HC_COLS));
 282                 return (ILBADM_LIBERR);
 283         }
 284
 285         rclib = ilb_open(&h);
 286         if (rclib != ILB_STATUS_OK)
 287                 goto out;
 288
 289         /* If no rule name is given, show results for all rules. */
 290         if (argc == 1) {
 291                 rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result, NULL,
 292                     ofmt_h);
 293         } else {
 294                 for (i = 1; i < argc; i++) {
 295                         rclib = ilb_walk_hc_srvs(h, ilbadm_print_hc_result,
 296                             argv[i], ofmt_h);
 297                         if (rclib != ILB_STATUS_OK)
 298                                 break;
 299                 }
 300         }
 301 out:
 302         ofmt_close(ofmt_h);
 303
 304         if (h != ILB_INVALID_HANDLE)
 305                 (void) ilb_close(h);
 306
 307         if (rclib != ILB_STATUS_OK) {
 308                 ilbadm_err(ilb_errstr(rclib));
 309                 return (ILBADM_LIBERR);
 310         }
 311         return (ILBADM_OK);
 312 }
 313
 314 #define ILBADM_DEF_HC_COUNT     3
 315 #define ILBADM_DEF_HC_INTERVAL  30      /* in sec */
 316 #define ILBADM_DEF_HC_TIMEOUT   5       /* in sec */
 317
 318 static ilbadm_key_name_t hc_parse_keys[] = {
 319         {ILB_KEY_HC_TEST, "hc-test", "hc-test"},
 320         {ILB_KEY_HC_COUNT, "hc-count", "hc-count"},
 321         {ILB_KEY_HC_TIMEOUT, "hc-timeout", "hc-tout"},
 322         {ILB_KEY_HC_INTERVAL, "hc-interval", "hc-intl"},
 323         {ILB_KEY_BAD, "", ""}
 324 };
 325
 326 static ilbadm_status_t
 327 ilbadm_hc_parse_arg(char *arg, ilb_hc_info_t *hc)
 328 {
 329         ilbadm_status_t ret;
 330
 331         /* set default value for count, interval, timeout */
 332         hc->hci_count = ILBADM_DEF_HC_COUNT;
 333         hc->hci_interval = ILBADM_DEF_HC_INTERVAL;
 334         hc->hci_timeout = ILBADM_DEF_HC_TIMEOUT;
 335         hc->hci_test[0] = '\0';
 336
 337         ret = i_parse_optstring(arg, hc, hc_parse_keys, 0, NULL);
 338         if (ret != ILBADM_OK && ret != ILBADM_LIBERR) {
 339                 ilbadm_err(ilbadm_errstr(ret));
 340                 return (ILBADM_LIBERR);
 341         }
 342         if (hc->hci_test[0] == '\0' && ret != ILBADM_LIBERR) {
 343                 ilbadm_err("hc-test: missing");
 344                 return (ILBADM_LIBERR);
 345         }
 346         return (ret);
 347 }
 348
 349 /* ARGSUSED */
 350 ilbadm_status_t
 351 ilbadm_create_hc(int argc, char *argv[])
 352 {
 353         ilb_handle_t    h = ILB_INVALID_HANDLE;
 354         ilb_hc_info_t   hc_info;
 355         ilbadm_status_t ret = ILBADM_OK;
 356         ilb_status_t    rclib;
 357         char            c;
 358
 359
 360         hc_info.hci_def_ping = B_TRUE;
 361         while ((c = getopt(argc, argv, ":h:n")) != -1) {
 362                 if (c == 'h') {
 363                         ret = ilbadm_hc_parse_arg(optarg, &hc_info);
 364                         if (ret != ILBADM_OK)
 365                                 return (ret);
 366                 } else if (c == 'n') {
 367                         hc_info.hci_def_ping = B_FALSE;
 368                 } else {
 369                         ilbadm_err(gettext("bad argument %c"), c);
 370                         return (ILBADM_LIBERR);
 371                 }
 372         }
 373
 374         if (optind >= argc) {
 375                 ilbadm_err(gettext("usage: ilbadm"
 376                     " create-healthcheck [-n] -h"
 377                     " hc-test=val[,hc-timeout=val][,hc-count=va]"
 378                     "[,hc-interval=val]  hc-name"));
 379                 return (ILBADM_FAIL);
 380         }
 381
 382         if (strlen(argv[optind]) > ILBD_NAMESZ - 1) {
 383                 ilbadm_err(gettext("health check object name %s is too long - "
 384                     "must not exceed %d chars"), argv[optind],
 385                     ILBD_NAMESZ - 1);
 386                 return (ILBADM_FAIL);
 387         }
 388
 389         if (((strcasecmp(hc_info.hci_test, ILB_HC_STR_UDP) == 0) ||
 390             (strcasecmp(hc_info.hci_test, ILB_HC_STR_PING) == 0)) &&
 391             !(hc_info.hci_def_ping)) {
 392                 ilbadm_err(gettext("cannot disable default PING"
 393                     " for this test"));
 394                 return (ILBADM_LIBERR);
 395         }
 396
 397         rclib = ilb_open(&h);
 398         if (rclib != ILB_STATUS_OK)
 399                 goto out;
 400
 401         (void) strlcpy(hc_info.hci_name, argv[optind],
 402             sizeof (hc_info.hci_name));
 403         rclib = ilb_create_hc(h, &hc_info);
 404 out:
 405         if (h != ILB_INVALID_HANDLE)
 406                 (void) ilb_close(h);
 407
 408         if (rclib != ILB_STATUS_OK) {
 409                 ilbadm_err(ilb_errstr(rclib));
 410                 ret = ILBADM_LIBERR;
 411         }
 412         return (ret);
 413 }
 414
 415 ilbadm_status_t
 416 ilbadm_destroy_hc(int argc, char *argv[])
 417 {
 418         ilb_handle_t    h = ILB_INVALID_HANDLE;
 419         ilb_status_t    rclib;
 420         ilbadm_status_t ret = ILBADM_OK;
 421         int             i;
 422
 423         if (argc < 2) {
 424                 ilbadm_err(gettext("usage: ilbadm"
 425                     " delete-healthcheck hc-name ..."));
 426                 return (ILBADM_LIBERR);
 427         }
 428
 429         rclib = ilb_open(&h);
 430         if (rclib != ILB_STATUS_OK)
 431                 goto out;
 432
 433         for (i = 1; i < argc; i++) {
 434                 rclib = ilb_destroy_hc(h, argv[i]);
 435                 if (rclib != ILB_STATUS_OK)
 436                         break;
 437         }
 438 out:
 439         if (h != ILB_INVALID_HANDLE)
 440                 (void) ilb_close(h);
 441
 442         if (rclib != ILB_STATUS_OK) {
 443                 ilbadm_err(ilb_errstr(rclib));
 444                 ret = ILBADM_LIBERR;
 445         }
 446         return (ret);
 447 }
 448
 449 /*
 450  * Since this function is used by libilb function, it
 451  * must return libilb errors
 452  */
 453 /* ARGSUSED */
 454 ilb_status_t
 455 ilbadm_export_hcinfo(ilb_handle_t h, ilb_hc_info_t *hc_info, void *arg)
 456 {
 457         FILE            *fp = ((hc_export_arg_t *)arg)->fp;
 458         int             count = 0;
 459         int             ret;
 460
 461         /*
 462          * a test name "PING" implies "no default ping", so we only
 463          * print -n if the test is NOT "PING"
 464          */
 465         if (hc_info->hci_def_ping == B_FALSE &&
 466             strncasecmp(hc_info->hci_test, "PING", 5) != 0)
 467                 (void) fprintf(fp, "create-healthcheck -n -h ");
 468         else
 469                 (void) fprintf(fp, "create-healthcheck -h ");
 470
 471         if (*hc_info->hci_test != '\0') {
 472                 (void) fprintf(fp, "hc-test=%s", hc_info->hci_test);
 473                 count++;
 474         }
 475         if (hc_info->hci_timeout != 0) {
 476                 if (count++ > 0)
 477                         (void) fprintf(fp, ",");
 478                 (void) fprintf(fp, "hc-timeout=%d", hc_info->hci_timeout);
 479         }
 480         if (hc_info->hci_count != 0) {
 481                 if (count++ > 0)
 482                         (void) fprintf(fp, ",");
 483                 (void) fprintf(fp, "hc-count=%d", hc_info->hci_count);
 484         }
 485         if (hc_info->hci_interval != 0) {
 486                 if (count > 0)
 487                         (void) fprintf(fp, ",");
 488                 (void) fprintf(fp, "hc-interval=%d", hc_info->hci_interval);
 489         }
 490
 491         /*
 492          * if any of the above writes fails, then, we assume, so will
 493          * this one; so it's sufficient to test once
 494          */
 495         ret = fprintf(fp, " %s\n", hc_info->hci_name);
 496         if (ret < 0)
 497                 goto out_fail;
 498         ret = fflush(fp);
 499
 500 out_fail:
 501         if (ret < 0)
 502                 return (ILB_STATUS_WRITE);
 503         return (ILB_STATUS_OK);
 504 }
 505
 506 ilbadm_status_t
 507 ilbadm_export_hc(ilb_handle_t h, FILE *fp)
 508 {
 509         ilb_status_t    rclib;
 510         ilbadm_status_t ret = ILBADM_OK;
 511         hc_export_arg_t arg;
 512
 513         arg.fp = fp;
 514         rclib = ilb_walk_hc(h, ilbadm_export_hcinfo, (void *)&arg);
 515         if (rclib != ILB_STATUS_OK) {
 516                 ilbadm_err(ilb_errstr(rclib));
 517                 ret = ILBADM_LIBERR;
 518         }
 519         return (ret);
 520 }