/*
 * 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.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <stddef.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/list.h>
#include <ofmt.h>
#include <libilb.h>
#include "ilbadm.h"

static ilbadm_key_name_t servrange_keys[] = {
        {ILB_KEY_SERVER, "server", "servers"},
        {ILB_KEY_SERVRANGE, "server", "servers"},
        {ILB_KEY_BAD, "", ""}
};

static ilbadm_key_name_t serverID_keys[] = {
        {ILB_KEY_SERVERID, "server", ""},
        {ILB_KEY_BAD, "", ""}
};

typedef struct sg_export_arg {
        FILE            *fp;
        ilbadm_sgroup_t *sg;
} sg_export_arg_t;

typedef struct arg_struct {
        int             flags;
        char            *o_str;
        ofmt_field_t    *o_fields;
        ofmt_handle_t   oh;
} list_arg_t;

typedef struct sg_srv_o_struct {
        char            *sgname;
        ilb_server_data_t       *sd;
} sg_srv_o_arg_t;

static ofmt_cb_t of_sgname;
static ofmt_cb_t of_srvID;
static ofmt_cb_t of_port;
static ofmt_cb_t of_ip;

static ofmt_field_t sgfields_v4[] = {
        {"SGNAME", ILB_SGNAME_SZ, 0, of_sgname},
        {"SERVERID", ILB_NAMESZ, 0, of_srvID},
        {"MINPORT", 8, 0, of_port},
        {"MAXPORT", 8, 1, of_port},
        {"IP_ADDRESS", 15, 0, of_ip},
        {NULL, 0, 0, NULL}
};
static ofmt_field_t sgfields_v6[] = {
        {"SGNAME", ILB_SGNAME_SZ, 0, of_sgname},
        {"SERVERID", ILB_NAMESZ, 0, of_srvID},
        {"MINPORT", 8, 0, of_port},
        {"MAXPORT", 8, 1, of_port},
        {"IP_ADDRESS", 39, 0, of_ip},
        {NULL, 0, 0, NULL}
};

#define MAXCOLS 80 /* make flexible? */

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

static boolean_t
of_sgname(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        sg_srv_o_arg_t  *l = (sg_srv_o_arg_t *)of_arg->ofmt_cbarg;

        (void) strlcpy(buf, l->sgname, bufsize);
        return (B_TRUE);
}

static boolean_t
of_srvID(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        sg_srv_o_arg_t  *l = (sg_srv_o_arg_t *)of_arg->ofmt_cbarg;

        (void) strlcpy(buf, l->sd->sd_srvID, bufsize);
        return (B_TRUE);
}

static boolean_t
of_port(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        sg_srv_o_arg_t  *l = (sg_srv_o_arg_t *)of_arg->ofmt_cbarg;
        int             port;

        if (of_arg->ofmt_id == 0) {
                port = ntohs(l->sd->sd_minport);
                if (port == 0)
                        *buf = '\0';
                else
                        (void) snprintf(buf, bufsize, "%d", port);
        } else {
                port = ntohs(l->sd->sd_maxport);
                if (port == 0)
                        *buf = '\0';
                else
                        (void) snprintf(buf, bufsize, "%d", port);
        }
        return (B_TRUE);
}

static boolean_t
of_ip(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        sg_srv_o_arg_t  *l = (sg_srv_o_arg_t *)of_arg->ofmt_cbarg;

        ip2str(&l->sd->sd_addr, buf, bufsize, V6_ADDRONLY);
        return (B_TRUE);
}

ilbadm_status_t
i_list_sg_srv_ofmt(char *sgname, ilb_server_data_t *sd, void *arg)
{
        list_arg_t      *larg = (list_arg_t *)arg;
        sg_srv_o_arg_t  line_arg;

        line_arg.sgname = sgname;
        line_arg.sd = sd;
        ofmt_print(larg->oh, &line_arg);
        return (ILBADM_OK);
}

/*
 * This function is always called via ilb_walk_servergroups()
 * and so must return libilb errors.
 * That's why we need to retain currently unused "h" argument
 */
/* ARGSUSED */
static ilb_status_t
ilbadm_list_sg_srv(ilb_handle_t h, ilb_server_data_t *sd, const char *sgname,
    void *arg)
{
        char            ip_str[2*INET6_ADDRSTRLEN + 3] = "";
        char            port_str[INET6_ADDRSTRLEN];
        list_arg_t      *larg = (list_arg_t *)arg;
        ofmt_status_t   oerr;
        int             oflags = 0;
        int             ocols = MAXCOLS;
        int             h_minport, h_maxport;
        static ofmt_handle_t    oh = (ofmt_handle_t)NULL;
        ofmt_field_t    *ofp;

        if (larg->o_str != NULL) {
                if (oh == NULL) {
                        if (sd->sd_addr.ia_af == AF_INET)
                                ofp = sgfields_v6;
                        else
                                ofp = sgfields_v4;

                        if (larg->flags & ILBADM_LIST_PARSE)
                                oflags |= OFMT_PARSABLE;

                        oerr = ofmt_open(larg->o_str, ofp, oflags, ocols, &oh);
                        if (oerr != OFMT_SUCCESS) {
                                char    e[80];

                                ilbadm_err(gettext("ofmt_open failed: %s"),
                                    ofmt_strerror(oh, oerr, e, sizeof (e)));
                                return (ILB_STATUS_GENERIC);
                        }
                        larg->oh = oh;
                }


                (void) i_list_sg_srv_ofmt((char *)sgname, sd, arg);
                return (ILB_STATUS_OK);
        }

        ip2str(&sd->sd_addr, ip_str, sizeof (ip_str), 0);

        h_minport = ntohs(sd->sd_minport);
        h_maxport = ntohs(sd->sd_maxport);
        if (h_minport == 0)
                *port_str = '\0';
        else if (h_maxport > h_minport)
                (void) sprintf(port_str, ":%d-%d", h_minport, h_maxport);
        else
                (void) sprintf(port_str, ":%d", h_minport);

        (void) printf("%s: id:%s %s%s\n", sgname,
            sd->sd_srvID, ip_str, port_str);
        return (ILB_STATUS_OK);
}

ilb_status_t
ilbadm_list_sg(ilb_handle_t h, ilb_sg_data_t *sg, void *arg)
{
        if (sg->sgd_srvcount == 0) {
                ilb_server_data_t       tmp_srv;

                bzero(&tmp_srv, sizeof (tmp_srv));
                return (ilbadm_list_sg_srv(h, &tmp_srv, sg->sgd_name, arg));
        }

        return (ilb_walk_servers(h, ilbadm_list_sg_srv, sg->sgd_name, arg));
}

static char *def_fields = "SGNAME,SERVERID,MINPORT,MAXPORT,IP_ADDRESS";

/* ARGSUSED */
ilbadm_status_t
ilbadm_show_servergroups(int argc, char *argv[])
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        int             c;
        char            optstr[] = ":po:";

        boolean_t       o_opt = B_FALSE, p_opt = B_FALSE;
        list_arg_t      larg = {0, def_fields, NULL, NULL};

        while ((c = getopt(argc, argv, optstr)) != -1) {
                switch ((char)c) {
                case 'p': p_opt = B_TRUE;
                        larg.flags |= ILBADM_LIST_PARSE;
                        break;
                case 'o': larg.o_str = optarg;
                        o_opt = B_TRUE;
                        break;
                case ':': ilbadm_err(gettext("missing option argument"
                            " for %c"), (char)optopt);
                        rc = ILBADM_LIBERR;
                        goto out;
                default: unknown_opt(argv, optind-1);
                        /* not reached */
                        break;
                }
        }

        if (p_opt && !o_opt) {
                ilbadm_err(gettext("option -p requires -o"));
                exit(1);
        }

        if (p_opt && larg.o_str != NULL &&
            (strcasecmp(larg.o_str, "all") == 0)) {
                ilbadm_err(gettext("option -p requires explicit field"
                    " names for -o"));
                exit(1);
        }

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

        if (optind >= argc) {
                rclib = ilb_walk_servergroups(h, ilbadm_list_sg, NULL,
                    (void*)&larg);
                if (rclib != ILB_STATUS_OK)
                        rc = ILBADM_LIBERR;
        } else {
                while (optind < argc) {
                        rclib = ilb_walk_servergroups(h, ilbadm_list_sg,
                            argv[optind++], (void*)&larg);
                        if (rclib != ILB_STATUS_OK) {
                                rc = ILBADM_LIBERR;
                                break;
                        }
                }
        }

        if (larg.oh != NULL)
                ofmt_close(larg.oh);
out:
        if (h != ILB_INVALID_HANDLE)
                (void) ilb_close(h);

        if (rclib != ILB_STATUS_OK) {
                /*
                 * The show function returns ILB_STATUS_GENERIC after printing
                 * out an error message.  So we don't need to print it again.
                 */
                if (rclib != ILB_STATUS_GENERIC)
                        ilbadm_err(ilb_errstr(rclib));
                rc = ILBADM_LIBERR;
        }

        return (rc);
}

ilbadm_servnode_t *
i_new_sg_elem(ilbadm_sgroup_t *sgp)
{
        ilbadm_servnode_t *s;

        s = (ilbadm_servnode_t *)calloc(sizeof (*s), 1);
        if (s != NULL) {
                list_insert_tail(&sgp->sg_serv_list, s);
                sgp->sg_count++;
        }
        return (s);
}

static ilbadm_status_t
i_parse_servrange_list(char *arg, ilbadm_sgroup_t *sgp)
{
        ilbadm_status_t rc;
        int             count;

        rc = i_parse_optstring(arg, (void *) sgp, servrange_keys,
            OPT_VALUE_LIST|OPT_IP_RANGE|OPT_PORTS, &count);
        return (rc);
}

static ilbadm_status_t
i_parse_serverIDs(char *arg, ilbadm_sgroup_t *sgp)
{
        ilbadm_status_t rc;
        int             count;

        rc = i_parse_optstring(arg, (void *) sgp, serverID_keys,
            OPT_VALUE_LIST|OPT_PORTS, &count);
        return (rc);
}

static ilbadm_status_t
i_mod_sg(ilb_handle_t h, ilbadm_sgroup_t *sgp, ilbadm_cmd_t cmd,
    int flags)
{
        ilbadm_servnode_t       *sn;
        ilb_server_data_t       *srv;
        ilb_status_t            rclib = ILB_STATUS_OK;
        ilbadm_status_t         rc = ILBADM_OK;

        if (h == ILB_INVALID_HANDLE && cmd != cmd_enable_server &&
            cmd != cmd_disable_server)
                return (ILBADM_LIBERR);

        sn = list_head(&sgp->sg_serv_list);
        while (sn != NULL) {
                srv = &sn->s_spec;

                srv->sd_flags |= flags;
                if (cmd == cmd_create_sg || cmd == cmd_add_srv) {
                        rclib = ilb_add_server_to_group(h, sgp->sg_name,
                            srv);
                        if (rclib != ILB_STATUS_OK) {
                                char    buf[INET6_ADDRSTRLEN + 1];

                                rc = ILBADM_LIBERR;
                                ip2str(&srv->sd_addr, buf, sizeof (buf),
                                    V6_ADDRONLY);
                                ilbadm_err(gettext("cannot add %s to %s: %s"),
                                    buf, sgp->sg_name, ilb_errstr(rclib));
                                /* if we created the SG, we bail out */
                                if (cmd == cmd_create_sg)
                                        return (rc);
                        }
                } else {
                        assert(cmd == cmd_rem_srv);
                        rclib = ilb_rem_server_from_group(h, sgp->sg_name,
                            srv);
                        /* if we fail, we tell user and continue */
                        if (rclib != ILB_STATUS_OK) {
                                rc = ILBADM_LIBERR;
                                ilbadm_err(
                                    gettext("cannot remove %s from %s: %s"),
                                    srv->sd_srvID, sgp->sg_name,
                                    ilb_errstr(rclib));
                        }
                }

                /*
                 * list_next returns NULL instead of cycling back to head
                 * so we don't have to check for list_head explicitly.
                 */
                sn = list_next(&sgp->sg_serv_list, sn);
        };

        return (rc);
}

static void
i_ilbadm_alloc_sgroup(ilbadm_sgroup_t **sgp)
{
        ilbadm_sgroup_t *sg;

        *sgp = sg = (ilbadm_sgroup_t *)calloc(sizeof (*sg), 1);
        if (sg == NULL)
                return;
        list_create(&sg->sg_serv_list, sizeof (ilbadm_servnode_t),
            offsetof(ilbadm_servnode_t, s_link));
}

static void
i_ilbadm_free_sgroup(ilbadm_sgroup_t *sg)
{
        ilbadm_servnode_t       *s;

        while ((s = list_remove_head(&sg->sg_serv_list)) != NULL)
                free(s);

        list_destroy(&sg->sg_serv_list);
}

ilbadm_status_t
ilbadm_create_servergroup(int argc, char *argv[])
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        ilbadm_sgroup_t *sg;
        int             c;
        int             flags = 0;

        i_ilbadm_alloc_sgroup(&sg);

        while ((c = getopt(argc, argv, ":s:")) != -1) {
                switch ((char)c) {
                case 's':
                        rc = i_parse_servrange_list(optarg, sg);
                        break;
                case ':':
                        ilbadm_err(gettext("missing option-argument for"
                            " %c"), (char)optopt);
                        rc = ILBADM_LIBERR;
                        break;
                case '?':
                default:
                        unknown_opt(argv, optind-1);
                        /* not reached */
                        break;
                }

                if (rc != ILBADM_OK)
                        goto out;
        }

        if (optind >= argc) {
                ilbadm_err(gettext("missing mandatory arguments - please refer"
                    " to 'create-servergroup' subcommand"
                    "  description in ilbadm(8)"));
                rc = ILBADM_LIBERR;
                goto out;
        }

        if (strlen(argv[optind]) > ILB_SGNAME_SZ - 1) {
                ilbadm_err(gettext("servergroup name %s is too long -"
                    " must not exceed %d chars"), argv[optind],
                    ILB_SGNAME_SZ - 1);
                rc = ILBADM_LIBERR;
                goto out;
        }

        sg->sg_name = argv[optind];

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

        rclib = ilb_create_servergroup(h, sg->sg_name);
        if (rclib != ILB_STATUS_OK)
                goto out;

        /* we create a servergroup with all servers enabled */
        ILB_SET_ENABLED(flags);
        rc = i_mod_sg(h, sg, cmd_create_sg, flags);

        if (rc != ILBADM_OK)
                (void) ilb_destroy_servergroup(h, sg->sg_name);

out:
        i_ilbadm_free_sgroup(sg);
        if (h != ILB_INVALID_HANDLE)
                (void) ilb_close(h);

        if (rclib != ILB_STATUS_OK) {
                ilbadm_err(ilb_errstr(rclib));
                rc = ILBADM_LIBERR;
        }
        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));

        return (rc);
}

ilbadm_status_t
ilbadm_add_server_to_group(int argc, char **argv)
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        ilbadm_sgroup_t *sg;
        int             c;
        int             flags = 0;

        i_ilbadm_alloc_sgroup(&sg);

        while ((c = getopt(argc, argv, ":s:")) != -1) {
                switch ((char)c) {
                case 's':
                        rc = i_parse_servrange_list(optarg, sg);
                        break;
                case ':':
                        ilbadm_err(gettext("missing option-argument for"
                            " %c"), (char)optopt);
                        rc = ILBADM_LIBERR;
                        break;
                case '?':
                default: unknown_opt(argv, optind-1);
                        /* not reached */
                        break;
                }

                if (rc != ILBADM_OK)
                        goto out;
        }

        if (optind >= argc) {
                ilbadm_err(gettext("missing mandatory arguments - please refer"
                    " to 'add-server' subcommand description in ilbadm(8)"));
                rc = ILBADM_LIBERR;
                goto out;
        }

        sg->sg_name = argv[optind];

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

        /* A server is added enabled */
        ILB_SET_ENABLED(flags);
        rc = i_mod_sg(h, sg, cmd_add_srv, flags);
out:
        i_ilbadm_free_sgroup(sg);
        if (h != ILB_INVALID_HANDLE)
                (void) ilb_close(h);

        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));
        return (rc);
}

/* ARGSUSED */
static ilbadm_status_t
ilbadm_Xable_server(int argc, char *argv[], ilbadm_cmd_t cmd)
{
        ilb_handle_t            h = ILB_INVALID_HANDLE;
        ilbadm_status_t         rc = ILBADM_OK;
        ilb_status_t            rclib = ILB_STATUS_OK;
        int                     i;

        if (argc < 2) {
                ilbadm_err(gettext("missing required argument"
                    " (server specification)"));
                rc = ILBADM_LIBERR;
                goto out;
        }

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

        /* enable-server and disable-server only accepts serverids */
        for (i = 1; i < argc && rclib == ILB_STATUS_OK; i++) {
                ilb_server_data_t       srv;

                if (argv[i][0] != ILB_SRVID_PREFIX) {
                        rc = ILBADM_INVAL_SRVID;
                        goto out;
                }

                bzero(&srv, sizeof (srv));
                /* to do: check length */
                (void) strlcpy(srv.sd_srvID, argv[i], sizeof (srv.sd_srvID));
                switch (cmd) {
                case cmd_enable_server:
                        rclib = ilb_enable_server(h, &srv, NULL);
                        break;
                case cmd_disable_server:
                        rclib = ilb_disable_server(h, &srv, NULL);
                        break;
                }

                /* if we can't find a given server ID, just plough on */
                if (rclib == ILB_STATUS_ENOENT) {
                        const char *msg = ilb_errstr(rclib);

                        rc = ILBADM_LIBERR;
                        ilbadm_err("%s: %s", msg, argv[i]);
                        rclib = ILB_STATUS_OK;
                        continue;
                }
                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));
                rc = ILBADM_LIBERR;
        }

        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));
        return (rc);
}

ilbadm_status_t
ilbadm_disable_server(int argc, char *argv[])
{
        return (ilbadm_Xable_server(argc, argv, cmd_disable_server));
}

ilbadm_status_t
ilbadm_enable_server(int argc, char *argv[])
{
        return (ilbadm_Xable_server(argc, argv, cmd_enable_server));
}

/* ARGSUSED */
ilbadm_status_t
ilbadm_rem_server_from_group(int argc, char *argv[])
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        ilbadm_sgroup_t *sg;
        int             c;

        i_ilbadm_alloc_sgroup(&sg);

        while ((c = getopt(argc, argv, ":s:")) != -1) {
                switch ((char)c) {
                case 's':
                        rc = i_parse_serverIDs(optarg, sg);
                        break;
                case ':':
                        ilbadm_err(gettext("missing option-argument for"
                            " %c"), (char)optopt);
                        rc = ILBADM_LIBERR;
                        break;
                case '?':
                default: unknown_opt(argv, optind-1);
                        /* not reached */
                        break;
                }
                if (rc != ILBADM_OK)
                        goto out;
        }

        /* we need servergroup name and at least one serverID to remove */
        if (optind >= argc || sg->sg_count == 0) {
                rc = ILBADM_ENOOPTION;
                goto out;
        }

        sg->sg_name = argv[optind];

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

        rc = i_mod_sg(h, sg, cmd_rem_srv, 0);
out:
        i_ilbadm_free_sgroup(sg);

        if (h != ILB_INVALID_HANDLE)
                (void) ilb_close(h);
        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));
        return (rc);
}

ilbadm_status_t
ilbadm_destroy_servergroup(int argc, char *argv[])
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        char            *sgname;

        if (argc != 2) {
                ilbadm_err(gettext("usage:ilbadm"
                    " delete-servergroup groupname"));
                rc = ILBADM_LIBERR;
                goto out;
        }

        sgname = argv[1];

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

        rclib = ilb_destroy_servergroup(h, sgname);
out:
        if (h != ILB_INVALID_HANDLE)
                (void) ilb_close(h);

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

        return (rc);
}

#define BUFSZ   1024

static int
export_srv_spec(ilb_server_data_t *srv, char *buf, const int bufsize)
{
        int     len = 0, bufsz = (int)bufsize;

        ip2str(&srv->sd_addr, buf, bufsz, 0);

        len += strlen(buf);
        bufsz -= len;

        if (srv->sd_minport != 0) {
                in_port_t       h_min, h_max;
                int             inc;

                h_min = ntohs(srv->sd_minport);
                h_max = ntohs(srv->sd_maxport);

                /* to do: if service name was given, print that, not number */
                if (h_max <= h_min)
                        inc = snprintf(buf+len, bufsz, ":%d", h_min);
                else
                        inc = snprintf(buf+len, bufsz, ":%d-%d", h_min, h_max);

                if (inc > bufsz) /* too little space */
                        return (-1);
                len += inc;
        }

        return (len);
}


/*
 * this is called by ilb_walk_servers(), therefore we return ilb_status_t
 * not ilbadm_status, and retain an unused function argument
 */
/* ARGSUSED */
ilb_status_t
ilbadm_export_a_srv(ilb_handle_t h, ilb_server_data_t *srv, const char *sgname,
    void *arg)
{
        sg_export_arg_t *larg = (sg_export_arg_t *)arg;
        FILE            *fp = larg->fp;
        char            linebuf[BUFSZ]; /* XXXms make that dynamic */
        int             sz = BUFSZ;

        if (export_srv_spec(srv, linebuf, sz) == -1)
                return (ILB_STATUS_OK);

        (void) fprintf(fp, "add-server -s server=");

        (void) fprintf(fp, "%s %s\n", linebuf, sgname);
        return (ILB_STATUS_OK);
}

ilb_status_t
ilbadm_export_sg(ilb_handle_t h, ilb_sg_data_t *sg, void *arg)
{
        ilb_status_t    rc = ILB_STATUS_OK;
        sg_export_arg_t *larg = (sg_export_arg_t *)arg;
        FILE            *fp = larg->fp;

        (void) fprintf(fp, "create-servergroup %s\n", sg->sgd_name);
        if (sg->sgd_srvcount == 0)
                return (ILB_STATUS_OK);

        rc = ilb_walk_servers(h, ilbadm_export_a_srv, sg->sgd_name, arg);
        if (rc != ILB_STATUS_OK)
                goto out;

        if (fflush(fp) == EOF)
                rc = ILB_STATUS_WRITE;

out:
        return (rc);
}

ilbadm_status_t
ilbadm_export_servergroups(ilb_handle_t h, FILE *fp)
{
        ilb_status_t    rclib = ILB_STATUS_OK;
        ilbadm_status_t rc = ILBADM_OK;
        sg_export_arg_t arg;

        arg.fp = fp;
        arg.sg = NULL;

        rclib = ilb_walk_servergroups(h, ilbadm_export_sg, NULL, (void *)&arg);
        if (rclib != ILB_STATUS_OK) {
                ilbadm_err(ilb_errstr(rclib));
                rc = ILBADM_LIBERR;
        }

        return (rc);
}