/*
 * 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <strings.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <libilb.h>
#include "ilbadm.h"

static ilbadm_cmd_help_t create_sg_help = {
"[-s server=hostspec[:portspec...]] groupname"
};

static ilbadm_cmd_help_t create_rule_help = {
"[-e] [-p] -i vip=value,port=value[,protocol=value] \n"                 \
"       -m lbalg=value,type=value[,proxy-src=ip-range][,pmask=mask] \n"\
"       -h hc-name=value[,hc-port=value]] \n"                           \
"       [-t [conn-drain=N][,nat-timeout=N][,persist-timeout=N]] \n"     \
"       -o servergroup=value name"
};

static ilbadm_cmd_help_t destroy_rule_help = {
"-a | name ..."
};

static ilbadm_cmd_help_t add_server_help = {
"-s server=value[,value ...] servergroup"
};

static ilbadm_cmd_help_t remove_server_help = {
"-s server=value[,value ...] servergroup"
};


static ilbadm_cmd_help_t disable_server_help = {
"server ... "
};

static ilbadm_cmd_help_t enable_server_help = {
"server ..."
};

static ilbadm_cmd_help_t enable_rule_help = {
"[name ... ]"
};

static ilbadm_cmd_help_t disable_rule_help = {
"[name ... ]"
};

static ilbadm_cmd_help_t show_server_help = {
"[[-p] -o field[,field...]] [rulename ... ]"
};

static ilbadm_cmd_help_t showstats_help = {
"[-p] -o field[,...]] [-tdAvi]\n"                               \
"       [-r rulename|-s servername] [interval [count]]"
};

static ilbadm_cmd_help_t show_nat_help = {
"[count]"
};

static ilbadm_cmd_help_t show_persist_help = {
"[count]"
};

static ilbadm_cmd_help_t show_hc_help = {
"[hc-name]"
};

static ilbadm_cmd_help_t create_hc_help = {
"[-n] -h hc-test=value[,hc-timeout=value]\n"                    \
"       [,hc-count=value][,hc-interval=value] hcname"
};

static ilbadm_cmd_help_t destroy_hc_help = {
"name ..."
};

static ilbadm_cmd_help_t show_hc_result_help = {
"[rule-name]"
};

static ilbadm_cmd_help_t show_rule_help = {
"[-e|-d] [-f |[-p] -o key[,key ...]] [name ...]"
};

static ilbadm_cmd_help_t destroy_servergroup_help = {
"groupname"
};

static ilbadm_cmd_help_t show_servergroup_help = {
"[[-p] -o field[,field]] [name]"
};

static ilbadm_cmd_help_t export_config_help = {
"[filename]"
};

static ilbadm_cmd_help_t import_config_help = {
"[-p] [filename]"
};
static ilbadm_cmd_desc_t ilbadm_cmds[] = {
        {"create-rule", "create-rl", ilbadm_create_rule, &create_rule_help},
        {"delete-rule", "delete-rl", ilbadm_destroy_rule, &destroy_rule_help},
        {"enable-rule", "enable-rl", ilbadm_enable_rule, &enable_rule_help},
        {"disable-rule", "disable-rl", ilbadm_disable_rule,
            &disable_rule_help},
        {"show-rule", "show-rl", ilbadm_show_rules, &show_rule_help},

        {"create-servergroup", "create-sg", ilbadm_create_servergroup,
            &create_sg_help},
        {"delete-servergroup", "delete-sg", ilbadm_destroy_servergroup,
            &destroy_servergroup_help},
        {"show-servergroup", "show-sg", ilbadm_show_servergroups,
            &show_servergroup_help},

        {"add-server", "add-srv", ilbadm_add_server_to_group,
            &add_server_help},
        {"remove-server", "remove-srv", ilbadm_rem_server_from_group,
            &remove_server_help},
        {"disable-server", "disable-srv", ilbadm_disable_server,
            &disable_server_help},
        {"enable-server", "enable-srv", ilbadm_enable_server,
            &enable_server_help},
        {"show-server", "show-srv", ilbadm_show_server,
            &show_server_help},

        {"show-healthcheck", "show-hc", ilbadm_show_hc, &show_hc_help},
        {"create-healthcheck", "create-hc", ilbadm_create_hc, &create_hc_help},
        {"delete-healthcheck", "delete-hc", ilbadm_destroy_hc,
            &destroy_hc_help},
        {"show-hc-result", "show-hc-res", ilbadm_show_hc_result,
            &show_hc_result_help},

        {"export-config", "export-cf", ilbadm_export, &export_config_help},
        {"import-config", "import-cf", ilbadm_noimport, &import_config_help},

        {"show-statistics", "show-stats", ilbadm_show_stats, &showstats_help},
        {"show-nat", "show-nat", ilbadm_show_nat, &show_nat_help},
        {"show-persist", "show-pt", ilbadm_show_persist,
            &show_persist_help},
        {"", "", NULL, NULL}
};


/* ARGSUSED */
ilbadm_status_t
ilbadm_noimport(int argc, char *argv[])
{
        ilbadm_err(ilbadm_errstr(ILBADM_NORECURSIVE));
        return (ILBADM_LIBERR);
}

static void
print_cmd_short(char *name, FILE *fp, ilbadm_cmd_desc_t *cmd)
{
        char    *h;

        while (cmd->c_name[0] != '\0') {
                if (cmd->c_help != NULL &&
                    (h = cmd->c_help->h_help) != NULL)
                        (void) fprintf(fp, "%s %s|%s %s\n", name,
                            cmd->c_name, cmd->c_alias, h);
                else
                        (void) fprintf(fp, "%s %s|%s\n", name, cmd->c_name,
                            cmd->c_alias);
                cmd++;
        }
}

void
print_cmdlist_short(char *name, FILE *fp)
{
        print_cmd_short(name, fp, ilbadm_cmds);
}

#define IMPORT_FILE     0x1

static void
match_cmd(char *name, ilbadm_cmd_desc_t *cmds, cmdfunc_t *action, int flags)
{
        ilbadm_cmd_desc_t       *cmd;

        if ((flags & IMPORT_FILE) == IMPORT_FILE) {
                if (strcasecmp(name, "export-config") == 0 ||
                    strcasecmp(name, "export-cf") == 0) {
                        ilbadm_err(gettext("export from import file"
                            " not allowed"));
                        exit(1);
                }
        }

        for (cmd = &cmds[0]; cmd->c_name[0] != '\0'; cmd++) {
                if (strncasecmp(cmd->c_name, name, sizeof (cmd->c_name)) == 0 ||
                    strncasecmp(cmd->c_alias, name, sizeof (cmd->c_alias)) == 0)
                        break;
        }
        *action = cmd->c_action;
}

/*
 * read and parse commandline
 */
static ilbadm_status_t
ilb_import_cmdline(int argc, char *argv[], int flags)
{
        ilbadm_status_t rc = ILBADM_OK;
        cmdfunc_t       cmd;

        match_cmd(argv[0], ilbadm_cmds, &cmd, flags);

        if (*cmd != NULL) {
                rc = cmd(argc, argv);
        } else {
                rc = ILBADM_INVAL_COMMAND;
                ilbadm_err(ilbadm_errstr(rc));
        }

        return (rc);
}

#define CHUNK   10
#define LINESZ  1024

typedef struct {
        int     listsz;
        char    *arglist[1];
} arg_t;

static int
i_getln_to_argv(FILE *fp, arg_t **ap)
{
        static char     *linebuf = NULL;
        char    *stringp, *currp;
        char    delim[] = " \t\n";
        int     i;
        arg_t   *a = *ap;

#define STR_DIFF(s1, s2)        (int)((char *)s2 - (char *)s1)
#define STR_ADJ_SZ(sz, buf, s)  (sz - STR_DIFF(buf, s))

        if (linebuf == NULL)
                if ((linebuf = (char *)malloc(LINESZ)) == NULL)
                        return (0);

        stringp = currp = linebuf;
        i = 0;
read_next:
        if (fgets(currp, STR_ADJ_SZ(LINESZ, linebuf, currp), fp) == NULL)
                return (i);

        /* ignore lines starting with a # character */
        if (*currp == '#')
                goto read_next;

        for (; stringp != NULL && currp != NULL; i++) {
                currp = strsep(&stringp, delim);
                /*
                 * if there's more than one adjacent delimiters ...
                 */
                if (*currp == '\0') {
                        i--;
                        continue;
                }
                /*
                 * if we find a '\' at the end of a line, treat
                 * it as a continuation character.
                 */
                if (*currp == '\\' && stringp == NULL) {
                        stringp = currp;
                        goto read_next;
                }
                if (a == NULL) {
                        a = (arg_t *)malloc(sizeof (*a));
                        bzero(a, sizeof (*a));
                }
                if (a->listsz <= i) {
                        int     sz;

                        a->listsz += CHUNK;
                        sz = sizeof (*a) +
                            ((a->listsz - 1) * sizeof (a->arglist));
                        a = (arg_t *)realloc(a, sz);
                        *ap = a;
                }
                a->arglist[i] = currp;
        }
        return (i);
}

static ilbadm_status_t
ilb_import_file(int fd, int flags)
{
        FILE            *fp;
        arg_t           *a = NULL;
        int             argcount;
        ilbadm_status_t rc = ILBADM_OK;

        if ((fp = fdopen(fd, "r")) == NULL) {
                ilbadm_err(gettext("cannot import file for reading"));
                exit(1);
        }

        if ((flags & ILBADM_IMPORT_PRESERVE) == 0) {
                ilb_handle_t    h = ILB_INVALID_HANDLE;
                ilb_status_t    rclib;

                rclib = ilb_open(&h);
                if (rclib == ILB_STATUS_OK)
                        (void) ilb_reset_config(h);
                if (h != ILB_INVALID_HANDLE)
                        (void) ilb_close(h);
        }

        while ((argcount = i_getln_to_argv(fp, &a)) > 0) {
                optind = 1;
                rc = ilb_import_cmdline(argcount, a->arglist, IMPORT_FILE);
                if (rc != ILBADM_OK)
                        break;
        }

        return (rc);
}

/*
 * this is the wrapper around everything to do with importing and
 * parsing either commandline or persistent storage.
 * if (fd == -1), parse commandline, otherwise use the given fd as input.
 */
/* ARGSUSED */
ilbadm_status_t
ilbadm_import(int fd, int argc, char *argv[], int flags)
{
        ilbadm_status_t rc;

        if (fd == -1)
                rc = ilb_import_cmdline(argc, argv, 0);
        else
                rc = ilb_import_file(fd, flags);

        return (rc);
}

ilbadm_status_t
ilbadm_export(int argc, char *argv[])
{
        ilb_handle_t    h = ILB_INVALID_HANDLE;
        ilbadm_status_t rc = ILBADM_OK;
        ilb_status_t    rclib = ILB_STATUS_OK;
        int             fd;
        FILE            *fp;
        char            *fname = NULL;
        char            tmpfile[MAXPATHLEN];

        if (argc < 2) {
                fd = 1;         /* stdout */
                *tmpfile = '\0';
        } else {
                fname = argv[1];
                (void) snprintf(tmpfile, sizeof (tmpfile), "%sXXXXXX", fname);
                fd = mkstemp(tmpfile);

                if (fd == -1) {
                        ilbadm_err(gettext("cannot create working file"));
                        exit(1);
                }
        }
        fp = fdopen(fd, "w");
        if (fp == NULL) {
                ilbadm_err(gettext("cannot open file for writing"), fd);
                exit(1);
        }

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

        rc = ilbadm_export_servergroups(h, fp);
        if (rc != ILBADM_OK)
                goto out;

        rc = ilbadm_export_hc(h, fp);
        if (rc != ILBADM_OK)
                goto out;

        rc = ilbadm_export_rules(h, fp);
        if (rc != ILBADM_OK)
                goto out;

        if (fname != NULL) {
                if (rename(tmpfile, fname) == -1) {
                        ilbadm_err(gettext("cannot create %s: %s"), fname,
                            strerror(errno));
                        exit(1);
                }
                *tmpfile = '\0';
        }

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

        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));
        (void) fclose(fp);
        if (*tmpfile != '\0')
                (void) unlink(tmpfile);
        return (rc);
}