/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <strings.h>
#include <elfedit.h>
#include "_elfedit.h"
#include "msg.h"




/*
 * This file provides the builtin sys module. It is similar to the
 * other modules, but differs in several important ways:
 *
 *      - It is built as a static part of elfedit, and not
 *              as a sharable object.
 *      - It must be avaialble before the ELFCLASS of the object
 *              is known, so it is not ELFCLASS specific. We don't build
 *              it twice with <sys/machelf.h>, as we do for the loadable
 *              modules. This means that commands need to test for the type
 *              of their obj_state argument at runtime.
 *      - The init function signature is different. We build an entire
 *              module definition statically.
 */



/*
 * This function is supplied to elfedit through our elfedit_module_t
 * definition. It translates the opaque elfedit_i18nhdl_t handles
 * in our module interface into the actual strings for elfedit to
 * use.
 *
 * note:
 *      This module uses Msg codes for its i18n handle type.
 *      So the translation is simply to use MSG_INTL() to turn
 *      it into a string and return it.
 */
static const char *
mod_i18nhdl_to_str(elfedit_i18nhdl_t hdl)
{
        Msg msg = (Msg)hdl;

        return (MSG_INTL(msg));
}



/*
 * The sys_opt_t enum specifies a bit value for every optional argument
 * allowed by a command in this module.
 */
typedef enum {
        SYS_OPT_F_ALL =         1,      /* -a */
        SYS_OPT_F_FORCE =       2,      /* -f */
        SYS_OPT_F_SYNOPSIS =    4,      /* -s */
} dyn_opt_t;


/*
 * Given a generic (void *) pointer to an obj_state argument, determine
 * which type it is, and return the st_file, st_fd and st_elf fields.
 */
static void
get_obj_state_info(void *obj_state, const char **file, int *fd, Elf **elf)
{
        if (state.elf.elfclass == ELFCLASS32) {
                elfedit32_obj_state_t *s = (elfedit32_obj_state_t *)obj_state;

                *file = s->os_file;
                *fd = s->os_fd;
                *elf = s->os_elf;
        } else {
                elfedit64_obj_state_t *s = (elfedit64_obj_state_t *)obj_state;

                *file = s->os_file;
                *fd = s->os_fd;
                *elf = s->os_elf;
        }
}



/*
 * Helper for cmd_help(). Displays synopsis information for one command.
 */
static void
cmd_help_synopsis(elfeditGC_module_t *mod, elfeditGC_cmd_t *cmd)
{
        char            name_buf[128];
        const char      *name;
        const char      **cmd_name;

        if (cmd->cmd_name[1] == NULL) {   /* One name */
                name = *cmd->cmd_name;
        } else {
                const char *cname;
                int need_comma = 0;

                name = name_buf;
                (void) snprintf(name_buf, sizeof (name_buf),
                    MSG_ORIG(MSG_HLPFMT_MULTNAM), cmd->cmd_name[0]);
                for (cmd_name = cmd->cmd_name + 1;
                    *cmd_name; cmd_name++) {
                        if (need_comma)
                                (void) strlcat(name_buf,
                                    MSG_ORIG(MSG_STR_COMMA_SP),
                                    sizeof (name_buf));
                        need_comma = 1;
                        cname = (cmd_name[0][0] == '\0') ?
                            MSG_INTL(MSG_HLPFMT_MODDEFCMD) : *cmd_name;
                        (void) strlcat(name_buf, cname,
                            sizeof (name_buf));
                }
                (void) strlcat(name_buf, MSG_ORIG(MSG_STR_CPAREN),
                    sizeof (name_buf));
        }
        elfedit_printf(MSG_ORIG(MSG_HLPFMT_NAMSUMHDR), name,
            (* mod->mod_i18nhdl_to_str)(cmd->cmd_desc));
        elfedit_printf(MSG_INTL(MSG_HLPFMT_SUMSYNOPSIS),
            elfedit_format_command_usage(mod, cmd,
            MSG_ORIG(MSG_STR_HLPSUMINDENT),
            strlen(MSG_ORIG(MSG_STR_HLPSUMINDENT))));
}


/*
 * Helper for cmd_help(). Displays synopsis information for one module.
 */
static void
cmd_help_showmod(elfeditGC_module_t *mod)
{
        elfeditGC_cmd_t *cmd;

        elfedit_printf(MSG_ORIG(MSG_HLPFMT_NAMDSCHDR),
            mod->mod_name, (* mod->mod_i18nhdl_to_str)(mod->mod_desc));
        for (cmd = mod->mod_cmds; cmd->cmd_func != NULL; cmd++) {
                if (cmd != mod->mod_cmds)
                        elfedit_printf(MSG_ORIG(MSG_STR_NL));
                elfedit_printf(MSG_ORIG(MSG_STR_NL));
                cmd_help_synopsis(mod, cmd);
        }
}


/*
 * Given a string containing newline characters, break it into
 * individual lines, and output each line with the given
 * prefix string in front.
 */
static void
write_help_str(const char *str, const char *prefix)
{
        size_t i;

        if (str == NULL)
                return;
        while (*str) {
                i = strcspn(str, MSG_ORIG(MSG_STR_NL));
                if (*(str + i) != '\0')
                        i++;
                elfedit_printf(prefix);
                elfedit_write(str, i);
                str += i;
        }
}


/*
 * Given a title, and a NULL terminated list of option/argument
 * descriptors, output the list contents.
 */
static void
write_optarg(elfeditGC_module_t *mod, const char *title,
    elfedit_cmd_optarg_t *optarg)
{
        int                     cnt;
        int                     len;
        const char              *help;
        elfedit_optarg_item_t   item;

        elfedit_printf(title);
        for (cnt = 0; optarg->oa_name != NULL; cnt++) {
                elfedit_next_optarg(&optarg, &item);

                /* Insert a blank line between items */
                if (cnt > 0)
                        elfedit_printf(MSG_ORIG(MSG_STR_NL));

                /* Indentation */
                elfedit_printf(MSG_ORIG(MSG_STR_HLPINDENT));
                len = strlen(item.oai_name);
                help = elfedit_optarg_helpstr(mod, &item);
                if (item.oai_flags & ELFEDIT_CMDOA_F_VALUE) {
                        len += 1 + strlen(item.oai_vname);
                        elfedit_printf(MSG_ORIG(MSG_STR_HLPOPTARG2),
                            item.oai_name, item.oai_vname);
                } else {
                        elfedit_printf(MSG_ORIG(MSG_STR_HLPOPTARG),
                            item.oai_name);
                }

                /*
                 * If name is too long, inject a newline to avoid
                 * crowding the help text.
                 */
                if (len > 3)
                        elfedit_printf(MSG_ORIG(MSG_STR_NL));

                /* Output the help text with a tab prefix */
                write_help_str(help, MSG_ORIG(MSG_STR_TAB));
        }
}


/*
 * Implementation of sys:help
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_help(void *obj_state, int argc, const char *argv[])
{
#define INITIAL_ITEM_ALLOC 4


        /*
         * An array of this type is used to collect the data needed to
         * generate help output.
         */
        typedef struct {
                elfeditGC_cmd_t         *cmd;
                elfeditGC_module_t      *cmd_mod;       /* Used with cmd */
                elfeditGC_module_t      *mod;
        } ITEM;

        static ITEM     *item;
        static int      item_cnt;

        MODLIST_T               *modlist;
        int                     dispcnt;
        size_t                  i;
        elfeditGC_module_t      *mod;
        elfeditGC_cmd_t         *cmd;
        int                     minus_s = 0;
        elfedit_getopt_state_t  getopt_state;
        ITEM                    *cur_item;

        /*
         * Process options. The only option accepted is -s, so we
         * don't even have to check the idmask to know.
         */
        elfedit_getopt_init(&getopt_state, &argc, &argv);
        while (elfedit_getopt(&getopt_state) != NULL)
                minus_s = 1;

        /*
         * This command can produce an arbitrary amount of output, so
         * run a pager.
         */
        elfedit_pager_init();

        if (argc == 0) {
                if (minus_s) {
                        /* Force all modules to load so we have data */
                        elfedit_load_modpath();
                        for (modlist = state.modlist; modlist;
                            modlist = modlist->ml_next) {
                                cmd_help_showmod(modlist->ml_mod);
                                if (modlist->ml_next != NULL) {
                                        elfedit_printf(MSG_ORIG(MSG_STR_NL));
                                        elfedit_printf(MSG_ORIG(MSG_STR_NL));
                                }
                        }
                        return (ELFEDIT_CMDRET_NONE);
                }

                /*
                 * If no arguments are present, we display a simple
                 * "how to use help" tutorial, which will hopefully
                 * bootstrap the user into a position where they
                 * know how to run the help command, and then find
                 * what they're really after.
                 */
                elfedit_printf(MSG_INTL(MSG_SYS_HELP_HELP_NOARG));
                return (ELFEDIT_CMDRET_NONE);
        }


        /*
         * As we process the arguments, we are willing to treat each
         * one as either a module or a command:
         *      1) An item without a colon can be a module,
         *              or a command from the sys: module.
         *      2) An item with a colon, and no command part is
         *              a module, and it can also be the default
         *              command for the module, if it has one. We choose
         *              to only display the module info in this case, since
         *              the use of "" to represent the default command is
         *              an implementation detail, not a user-facing concept.
         *      3) An item with a colon and a command part can only be
         *              a command.
         *
         * Note that there are cases where one argument can have two
         * valid interpretations. In this case, we display them both.
         *
         * Pass over the arguments and determine how many distinct
         * "things" we need to display. At the same time, force any
         * needed modules to load so that the debug load messages won't
         * show up in between the displayed items, and save the command
         * and module definitions we will need to generate the output.
         */
        if (argc > item_cnt) {
                int n = (item_cnt == 0) ? INITIAL_ITEM_ALLOC : item_cnt;

                while (n < argc)
                        n *= 2;

                item = elfedit_realloc(MSG_INTL(MSG_ALLOC_HELPITEM), item,
                    n * sizeof (*item));
                item_cnt = n;
        }

        dispcnt = 0;
        for (i = 0; i < argc; i++) {
                const char *colon = strchr(argv[i], ':');

                if (colon == NULL) {    /* No colon: sys: cmd or module */
                        item[i].cmd =
                            elfedit_find_command(argv[i], 0, &item[i].cmd_mod);
                        if (item[i].cmd != NULL)
                                dispcnt++;

                        /*
                         * Also try to load it as a module. If a command
                         * was found, then this need not succeed. Otherwise,
                         * it has to be a module, and we cause an error
                         * to be issued if not.
                         */
                        item[i].mod = elfedit_load_module(argv[i],
                            item[i].cmd == NULL, 0);
                        if (item[i].mod != NULL)
                                dispcnt++;
                } else if (*(colon + 1) == '\0') {
                        /* Just colon: Module (and maybe default command) */
                        char buf[ELFEDIT_MAXMODNAM + 1];
                        const char *str = argv[i];
                        int len = colon - str;

                        item[i].cmd = NULL;
                        /* Strip off the colon */
                        if (len < sizeof (buf)) {
                                (void) strncpy(buf, str, len);
                                buf[len] = '\0';
                                str = buf;
                        }
                        item[i].mod = elfedit_load_module(str, 1, 0);
                        dispcnt++;
                } else {        /* A command */
                        item[i].cmd =
                            elfedit_find_command(argv[i], 1, &item[i].cmd_mod);
                        dispcnt++;
                        item[i].mod = NULL;
                }
        }

        /*
         * Having validated the items, loop over them again and produce
         * the required help output.
         */
        for (cur_item = item; argc--; argv++, cur_item++) {


                /* Help for a module? */
                if (cur_item->mod != NULL) {
                        if (dispcnt > 1)
                                elfedit_printf(MSG_ORIG(MSG_HLPFMT_MULTIHDR),
                                    *argv);
                        cmd_help_showmod(cur_item->mod);
                        if ((dispcnt > 1) && (argc > 0))
                                elfedit_printf(MSG_INTL(MSG_HLPFMT_MULTIEND),
                                    argv[0], argv[1]);
                        /* An empty line after the last line of output */
                        elfedit_printf(MSG_ORIG(MSG_STR_NL));
                }

                /* Help for a command? */
                if (cur_item->cmd == NULL)
                        continue;
                cmd = cur_item->cmd;
                mod = cur_item->cmd_mod;
                if (dispcnt > 1)
                        elfedit_printf(MSG_ORIG(MSG_HLPFMT_MULTIHDR), *argv);

                /* If -s, display quick synopsis rather than the whole thing */
                if (minus_s) {
                        cmd_help_synopsis(mod, cmd);
                        continue;
                }

                elfedit_printf(MSG_INTL(MSG_HLPFMT_MOD), mod->mod_name,
                    (* mod->mod_i18nhdl_to_str)(mod->mod_desc));
                elfedit_printf(MSG_INTL(MSG_HLPFMT_NAME),
                    *cmd->cmd_name,
                    (* mod->mod_i18nhdl_to_str)(cmd->cmd_desc));
                elfedit_printf(MSG_INTL(MSG_HLPFMT_SYNOPSIS),
                    elfedit_format_command_usage(mod, cmd,
                    MSG_ORIG(MSG_STR_HLPUSEINDENT),
                    strlen(MSG_ORIG(MSG_STR_HLPINDENT))));
                /* If there are alias names, show them */
                if (cmd->cmd_name[1] != NULL) {
                        const char **alias = cmd->cmd_name + 1;

                        elfedit_printf(MSG_INTL(MSG_HLPFMT_ALIASES));
                        do {
                                elfedit_printf(
                                    MSG_ORIG(MSG_STR_HLPINDENT));
                                elfedit_printf(
                                    MSG_ORIG(MSG_FMT_MODCMD),
                                    mod->mod_name, *alias);
                                if (**alias == '\0')
                                        elfedit_printf(
                                            MSG_INTL(MSG_HLPFMT_DEFCMD));
                                elfedit_printf(MSG_ORIG(MSG_STR_NL));
                                alias++;
                        } while (*alias);
                }
                elfedit_printf(MSG_INTL(MSG_HLPFMT_DESC));
                write_help_str(
                    (* mod->mod_i18nhdl_to_str)(cmd->cmd_help),
                    MSG_ORIG(MSG_STR_HLPINDENT));
                if (cmd->cmd_args != NULL)
                        write_optarg(mod, MSG_INTL(MSG_HLPFMT_ARGS),
                            cmd->cmd_args);
                if (cmd->cmd_opt != NULL)
                        write_optarg(mod, MSG_INTL(MSG_HLPFMT_OPT),
                            cmd->cmd_opt);
                if ((dispcnt > 1) && (argc > 0))
                        elfedit_printf(MSG_INTL(MSG_HLPFMT_MULTIEND),
                            argv[0], argv[1]);
                /* An empty line after the last line of output */
                elfedit_printf(MSG_ORIG(MSG_STR_NL));
        }

        return (ELFEDIT_CMDRET_NONE);

#undef  INITIAL_ITEM_ALLOC
}


/*
 * Command completion function for sys:help
 */
/*ARGSUSED*/
static void
cpl_help(void *obj_state, void *cpldata, int argc, const char *argv[],
    int num_opt)
{
        /*
         * The arguments can be any module or command. Supplying the
         * commands implicitly supplies the modules too.
         */
        elfedit_cpl_command(cpldata);
}


/*
 * Implementation of sys:load
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_load(void *obj_state, int argc, const char *argv[])
{
        elfedit_getopt_state_t  getopt_state;
        elfedit_getopt_ret_t    *getopt_ret;
        struct stat             statbuf;

        elfedit_getopt_init(&getopt_state, &argc, &argv);
        while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL) {
                switch (getopt_ret->gor_idmask) {
                case SYS_OPT_F_ALL:
                        elfedit_load_modpath();
                        break;
                }
        }

        /* For each remaining argument, load them individually */
        for (; argc-- > 0; argv++) {
                /* Is it a directory? Load everything in it */
                if ((stat(*argv, &statbuf) == 0) &&
                    (statbuf.st_mode & S_IFDIR)) {
                        elfedit_load_moddir(*argv, 1, 1);
                } else {        /* Not a directory. Normal load */
                        (void) elfedit_load_module(*argv, 1, 1);
                }
        }

        return (0);
}


/*
 * Command completion function for sys:load
 */
/*ARGSUSED*/
static void
cpl_load(void *obj_state, void *cpldata, int argc, const char *argv[],
    int num_opt)
{
        /*
         * Module names. Note that this causes elfedit to load all
         * of the modules, which probably makes the current load
         * operation unnecessary. This could be improved, but I don't
         * see it as worth the complexity. Explicit load calls are
         * rare, and the user will usually not use command completion.
         */
        elfedit_cpl_module(cpldata, 1);
}


/*
 * Implementation of sys:quit
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_quit(void *obj_state, int argc, const char *argv[])
{
        elfedit_getopt_state_t  getopt_state;
        elfedit_getopt_ret_t    *getopt_ret;
        int                     force = 0;
        const char              *file;
        int                     fd;
        Elf                     *elf;

        elfedit_getopt_init(&getopt_state, &argc, &argv);
        while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL) {
                switch (getopt_ret->gor_idmask) {
                case SYS_OPT_F_FORCE:
                        force = 1;
                        break;
                }
        }
        if (argc != 0)
                elfedit_command_usage();

        if (state.file.present) {
                /*
                 * If session is not READONLY, then refuse to quit if file
                 * needs flushing and -f option was not used.
                 */
                if (!(state.flags & ELFEDIT_F_READONLY) && state.file.dirty &&
                    !force)
                        elfedit_msg(ELFEDIT_MSG_ERR,
                            MSG_INTL(MSG_ERR_NODIRTYQUIT));

                get_obj_state_info(obj_state, &file, &fd, &elf);
                (void) close(fd);
                (void) elf_end(elf);
                free(obj_state);
        }

        elfedit_exit(0);
        /*NOTREACHED*/
        return (0);
}


/*
 * Implementation of sys:status
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_status(void *obj_state, int argc, const char *argv[])
{
        MODLIST_T       *modlist;
        const char      *s;
        size_t          i;

        if (argc > 0)
                elfedit_command_usage();

        /*
         * This command can produce an arbitrary amount of output, so
         * run a pager.
         */
        elfedit_pager_init();

        /* Files */
        if (state.file.present == 0) {
                elfedit_printf(MSG_INTL(MSG_HLPFMT_INFILENONE));
        } else if (state.flags & ELFEDIT_F_READONLY) {
                elfedit_printf(MSG_INTL(MSG_HLPFMT_INFILERO),
                    state.file.infile);
        } else {
                elfedit_printf(MSG_INTL(MSG_HLPFMT_INFILE), state.file.infile);
                elfedit_printf(MSG_INTL(MSG_HLPFMT_OUTFILE),
                    state.file.outfile);
        }
        if (state.file.dirty)
                elfedit_printf(MSG_INTL(MSG_HLPFMT_CNGPENDING));

        /* Option Variables */
        elfedit_printf(MSG_INTL(MSG_HLPFMT_VARHDR));
        elfedit_printf(MSG_INTL(MSG_HLPFMT_AFLG),
            (state.flags & ELFEDIT_F_AUTOPRINT) ? MSG_ORIG(MSG_STR_ON) :
            MSG_ORIG(MSG_STR_OFF));
        elfedit_printf(MSG_INTL(MSG_HLPFMT_DFLG),
            (state.flags & ELFEDIT_F_DEBUG) ? MSG_ORIG(MSG_STR_ON) :
            MSG_ORIG(MSG_STR_OFF));
        elfedit_printf(MSG_INTL(MSG_HLPFMT_OFLG),
            elfedit_atoconst_value_to_str(ELFEDIT_CONST_OUTSTYLE,
            state.outstyle, 1));

        /* Module Load Path */
        elfedit_printf(MSG_INTL(MSG_HLPFMT_PATHHDR));
        for (i = 0; i < state.modpath.n; i++)
                elfedit_printf(MSG_ORIG(MSG_HLPFMT_PATHELT),
                    state.modpath.seg[i]);

        /* Currently Loaded Modules */
        elfedit_printf(MSG_INTL(MSG_HLPFMT_MODHDR));
        for (modlist = state.modlist; modlist;
            modlist = modlist->ml_next) {
                s = modlist->ml_path ? modlist->ml_path :
                    MSG_INTL(MSG_FMT_BUILTIN);
                elfedit_printf(MSG_ORIG(MSG_HLPFMT_NAMDSCCOL),
                    modlist->ml_mod->mod_name, s);
        }

        return (ELFEDIT_CMDRET_NONE);
}

/*
 * Implementation of sys:set
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_set(void *obj_state, int argc, const char *argv[])
{
        if ((argc != 2) || (strlen(argv[0]) > 1))
                elfedit_command_usage();

        switch (**argv) {
        case 'a':
        case 'A':
                if (elfedit_atobool(argv[1], MSG_INTL(MSG_SYSSET_A)))
                        state.flags |= ELFEDIT_F_AUTOPRINT;
                else
                        state.flags &= ~ELFEDIT_F_AUTOPRINT;
                break;

        case 'd':
        case 'D':
                if (elfedit_atobool(argv[1], MSG_INTL(MSG_SYSSET_D)))
                        state.flags |= ELFEDIT_F_DEBUG;
                else
                        state.flags &= ~ELFEDIT_F_DEBUG;
                break;

        case 'o':
        case 'O':
                if (elfedit_atooutstyle(argv[1], &state.outstyle) == 0)
                        elfedit_msg(ELFEDIT_MSG_ERR,
                            MSG_INTL(MSG_ERR_BADOSTYLE), argv[1]);
                break;

        default:
                elfedit_command_usage();
        }

        return (0);
}


/*
 * Command completion function for sys:set
 */
/*ARGSUSED*/
static void
cpl_set(void *obj_state, void *cpldata, int argc, const char *argv[],
    int num_opt)
{
        const char *s;

        /*
         * This command doesn't accept options, so num_opt should be
         * 0. This is a defensive measure, in case that should change.
         */
        argc -= num_opt;
        argv += num_opt;

        if ((argc < 1) || (argc > 2))
                return;

        if (argc == 1) {        /* The first argument is a variable letter */
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_A), 1);
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_D), 1);
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_O), 1);
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_W), 1);
                return;
        }

        /* We're dealing with the second argument, the value */
        s = argv[0];
        if (strlen(s) > 1)      /* One letter variables */
                return;
        switch (*s) {
        case 'a':               /* Booleans */
        case 'A':
        case 'd':
        case 'D':
        case 'w':
        case 'W':
                /* The second argument is a boolean */
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_BOOL);

                /* The numbers are not symbolic, but we want them in the list */
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_0), 1);
                elfedit_cpl_match(cpldata, MSG_ORIG(MSG_STR_1), 1);
                break;

        case 'o':               /* Output style */
        case 'O':
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_OUTSTYLE);
                break;
        }
}


/*
 * Implementation of sys:unload
 */
/*ARGSUSED*/
static elfedit_cmdret_t
cmd_unload(void *obj_state, int argc, const char *argv[])
{
        elfedit_getopt_state_t  getopt_state;
        elfedit_getopt_ret_t    *getopt_ret;
        MODLIST_T               *moddef;
        int                     do_all = 0;

        elfedit_getopt_init(&getopt_state, &argc, &argv);
        while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL) {
                switch (getopt_ret->gor_idmask) {
                case SYS_OPT_F_ALL:
                        do_all = 1;
                        break;
                }
        }

        /*
         * If -a is specified, unload everything except builtins. Don't
         * allow plain arguments in this case because there is nothing
         * left to unload after -a.
         */
        if (do_all) {
                if (argc > 0)
                        elfedit_command_usage();
                /*
                 * Until we run out of non-builtin modules, take the first
                 * one from the list and unload it. Each removal alters
                 * the list, so we always start at the beginning, but this
                 * is efficient since we always remove the first available item
                 */
                while (state.modlist != NULL) {
                        for (moddef = state.modlist; moddef != NULL;
                            moddef = moddef->ml_next)
                                if (moddef->ml_dl_hdl != NULL) break;

                        /* If we made it to the end, then the list is empty */
                        if (moddef == NULL)
                                break;

                        elfedit_unload_module(moddef->ml_mod->mod_name);
                }
                return (0);
        }

        /* Unload each module individually */
        for (; argc-- > 0; argv++)
                elfedit_unload_module(*argv);

        return (0);
}


/*
 * Command completion function for sys:unload
 */
/*ARGSUSED*/
static void
cpl_unload(void *obj_state, void *cpldata, int argc, const char *argv[],
    int num_opt)
{
        /*
         * Module names. Don't allow elfedit to load all the modules,
         * as the only modules we want to unload are those already
         * in memory.
         */
        elfedit_cpl_module(cpldata, 0);
}


/*
 * Implementation of sys:write
 */
/*ARGSUSED2*/
static elfedit_cmdret_t
cmd_write(void *obj_state, int argc, const char *argv[])
{
        const char      *file;
        int             fd;
        Elf             *elf;

        if (argc != 0)
                elfedit_command_usage();

        if (state.file.present != 0) {
                if (state.flags & ELFEDIT_F_READONLY)
                        elfedit_msg(ELFEDIT_MSG_ERR,
                            MSG_INTL(MSG_ERR_READONLY));

                get_obj_state_info(obj_state, &file, &fd, &elf);
                if (elf_update(elf, ELF_C_WRITE) == -1)
                        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_LIBELF),
                            file, MSG_ORIG(MSG_ELF_UPDATE),
                            elf_errmsg(elf_errno()));

                /*
                 * An update has succeeded for this file, so revoke the need
                 * to unlink it on exit.
                 */
                state.file.unlink_on_exit = 0;
        }

        return (ELFEDIT_CMDRET_FLUSH);
}





/*ARGSUSED*/
MODLIST_T *
elfedit_sys_init(elfedit_module_version_t version)
{
        /* sys:help */
        static const char *name_help[] = { MSG_ORIG(MSG_SYS_CMD_HELP),
            MSG_ORIG(MSG_SYS_CMD_HELP_A1), MSG_ORIG(MSG_SYS_CMD_HELP_A2),
            NULL };
        static elfedit_cmd_optarg_t opt_help[] = {
                { MSG_ORIG(MSG_STR_MINUS_S),
                    /* MSG_INTL(MSG_SYS_OPTDESC_HELP_S) */
                    ELFEDIT_I18NHDL(MSG_SYS_OPTDESC_HELP_S), 0,
                    SYS_OPT_F_SYNOPSIS, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_help[] = {
                { MSG_ORIG(MSG_STR_ARG),
                    /* MSG_INTL(MSG_ARGDESC_HELP_ARG) */
                    ELFEDIT_I18NHDL(MSG_ARGDESC_HELP_ARG),
                    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
                { NULL }
        };

        /* sys:load */
        static const char *name_load[] = {
            MSG_ORIG(MSG_SYS_CMD_LOAD), NULL };
        static elfedit_cmd_optarg_t opt_load[] = {
                { MSG_ORIG(MSG_STR_MINUS_A),
                    /* MSG_INTL(MSG_SYS_OPTDESC_LOAD_A) */
                    ELFEDIT_I18NHDL(MSG_SYS_OPTDESC_LOAD_A), 0,
                    SYS_OPT_F_ALL, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_load[] = {
                { MSG_ORIG(MSG_STR_MODNAME),
                    /* MSG_INTL(MSG_ARGDESC_LOAD_MODNAME) */
                    ELFEDIT_I18NHDL(MSG_ARGDESC_LOAD_MODNAME),
                    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
                { NULL }
        };

        /* sys:quit */
        static const char *name_quit[] = { MSG_ORIG(MSG_SYS_CMD_QUIT),
            MSG_ORIG(MSG_SYS_CMD_QUIT_A1), MSG_ORIG(MSG_SYS_CMD_QUIT_A2),
            NULL };
        static elfedit_cmd_optarg_t opt_quit[] = {
                { MSG_ORIG(MSG_STR_MINUS_F),
                    /* MSG_INTL(MSG_SYS_OPTDESC_QUIT_F) */
                    ELFEDIT_I18NHDL(MSG_SYS_OPTDESC_QUIT_F), 0,
                    SYS_OPT_F_FORCE, 0 },
                { NULL }
        };

        /* sys:status */
        static const char *name_status[] = {
            MSG_ORIG(MSG_SYS_CMD_STATUS), NULL };

        /* sys:set */
        static const char *name_set[] = {
            MSG_ORIG(MSG_SYS_CMD_SET), NULL };
        static elfedit_cmd_optarg_t arg_set[] = {
                { MSG_ORIG(MSG_STR_OPTION),
                    /* MSG_INTL(MSG_ARGDESC_SET_OPTION) */
                    ELFEDIT_I18NHDL(MSG_ARGDESC_SET_OPTION), 0 },
                { MSG_ORIG(MSG_STR_VALUE),
                    /* MSG_INTL(MSG_ARGDESC_SET_VALUE) */
                    ELFEDIT_I18NHDL(MSG_ARGDESC_SET_VALUE), 0 },
                { NULL }
        };

        /* sys:unload */
        static const char *name_unload[] = {
            MSG_ORIG(MSG_SYS_CMD_UNLOAD), NULL };
        static elfedit_cmd_optarg_t opt_unload[] = {
                { MSG_ORIG(MSG_STR_MINUS_A),
                    /* MSG_INTL(MSG_SYS_OPTDESC_UNLOAD_A) */
                    ELFEDIT_I18NHDL(MSG_SYS_OPTDESC_UNLOAD_A), 0,
                    SYS_OPT_F_ALL, 0},
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_unload[] = {
                { MSG_ORIG(MSG_STR_MODNAME),
                    /* MSG_INTL(MSG_ARGDESC_UNLOAD_MODNAME) */
                    ELFEDIT_I18NHDL(MSG_ARGDESC_UNLOAD_MODNAME),
                    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
                { NULL }
        };

        /* sys:write */
        static const char *name_write[] = { MSG_ORIG(MSG_SYS_CMD_WRITE),
            MSG_ORIG(MSG_SYS_CMD_WRITE_A1), MSG_ORIG(MSG_SYS_CMD_WRITE_A2),
            NULL };

        static elfedit_cmd_t cmds[] = {
                /* sym:help */
                { (elfedit_cmd_func_t *)cmd_help,
                    (elfedit_cmdcpl_func_t *)cpl_help, name_help,
                    /* MSG_INTL(MSG_SYS_DESC_HELP) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_HELP),
                    /* MSG_INTL(MSG_SYS_HELP_HELP) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_HELP),
                    opt_help, arg_help },

                /* sym:load */
                { (elfedit_cmd_func_t *)cmd_load,
                    (elfedit_cmdcpl_func_t *)cpl_load, name_load,
                    /* MSG_INTL(MSG_SYS_DESC_LOAD) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_LOAD),
                    /* MSG_INTL(MSG_SYS_HELP_LOAD) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_LOAD),
                    opt_load, arg_load },

                /* sym:quit */
                { (elfedit_cmd_func_t *)cmd_quit, NULL, name_quit,
                    /* MSG_INTL(MSG_SYS_DESC_QUIT) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_QUIT),
                    /* MSG_INTL(MSG_SYS_HELP_QUIT) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_QUIT),
                    opt_quit, NULL },

                /* sym:status */
                { (elfedit_cmd_func_t *)cmd_status, NULL, name_status,
                    /* MSG_INTL(MSG_SYS_DESC_STATUS) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_STATUS),
                    /* MSG_INTL(MSG_SYS_HELP_STATUS) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_STATUS),
                    NULL, NULL },

                /* sym:set */
                { (elfedit_cmd_func_t *)cmd_set,
                    (elfedit_cmdcpl_func_t *)cpl_set, name_set,
                    /* MSG_INTL(MSG_SYS_DESC_SET) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_SET),
                    /* MSG_INTL(MSG_SYS_HELP_SET) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_SET),
                    NULL, arg_set },

                /* sym:unload */
                { (elfedit_cmd_func_t *)cmd_unload,
                    (elfedit_cmdcpl_func_t *)cpl_unload, name_unload,
                    /* MSG_INTL(MSG_SYS_DESC_UNLOAD) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_UNLOAD),
                    /* MSG_INTL(MSG_SYS_HELP_UNLOAD) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_UNLOAD),
                    opt_unload, arg_unload },

                /* sym:write */
                { (elfedit_cmd_func_t *)cmd_write, NULL, name_write,
                    /* MSG_INTL(MSG_SYS_DESC_WRITE) */
                    ELFEDIT_I18NHDL(MSG_SYS_DESC_WRITE),
                    /* MSG_INTL(MSG_SYS_HELP_WRITE) */
                    ELFEDIT_I18NHDL(MSG_SYS_HELP_WRITE),
                    NULL, NULL},

                { NULL }
        };

        static elfedit_module_t module = {
            ELFEDIT_VER_CURRENT, MSG_ORIG(MSG_MOD_SYS),
            /* MSG_INTL(MSG_MOD_SYS_DESC) */
            ELFEDIT_I18NHDL(MSG_MOD_SYS_DESC),
            cmds, mod_i18nhdl_to_str };

        static MODLIST_T moddef = {
                NULL,           /* next */
                (elfeditGC_module_t *)&module,  /* Module definition */
                NULL,           /* Didn't dlopen() it, so NULL handle */
                NULL            /* Didn't dlopen() it, so no file path */
        };

        return (&moddef);
}