sys.c revision d29b2c4438482eb00488be49a1f5d6835f455546
/*
* 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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#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 machdep.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);
}