cap.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 <ctype.h>
#include <machdep.h>
#include <elfedit.h>
#include <sys/elf_SPARC.h>
#include <strings.h>
#include <debug.h>
#include <conv.h>
#include <cap_msg.h>
/*
* Capabilities section
*/
/*
* This module uses shared code for several of the commands.
* It is sometimes necessary to know which specific command
* is active.
*/
typedef enum {
/* Dump command, used as module default to display dynamic section */
CAP_CMD_T_DUMP = 0, /* cap:dump */
/* Commands that do not correspond directly to a specific DT tag */
CAP_CMD_T_TAG = 1, /* cap:tag */
CAP_CMD_T_VALUE = 2, /* cap:value */
CAP_CMD_T_DELETE = 3, /* cap:delete */
CAP_CMD_T_MOVE = 4, /* cap:shift */
/* Commands that embody tag specific knowledge */
CAP_CMD_T_HW1 = 5, /* cap:hw1 */
CAP_CMD_T_SF1 = 6, /* cap:sf1 */
} CAP_CMD_T;
#ifndef _ELF64
/*
* We supply this function for the msg module
*/
const char *
_cap_msg(Msg mid)
{
return (gettext(MSG_ORIG(mid)));
}
#endif
/*
* 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 cap_opt_t enum specifies a bit value for every optional
* argument allowed by a command in this module.
*/
typedef enum {
CAP_OPT_F_AND = 1, /* -and: AND (&) values to dest */
CAP_OPT_F_CMP = 2, /* -cmp: Complement (~) values */
CAP_OPT_F_CAPNDX = 4, /* -capndx: elt is tag index, */
/* not name */
CAP_OPT_F_OR = 8, /* -or: OR (|) values to dest */
} cap_opt_t;
/*
* A variable of type ARGSTATE is used by each command to maintain
* information about the arguments and related things. It is
* initialized by process_args(), and used by the other routines.
*/
typedef struct {
elfedit_obj_state_t *obj_state;
struct {
elfedit_section_t *sec; /* Capabilities section reference */
Cap *data; /* Start of capabilities section data */
Word num; /* # Capabilities elts */
} cap;
cap_opt_t optmask; /* Mask of options used */
int argc; /* # of plain arguments */
const char **argv; /* Plain arguments */
} ARGSTATE;
/*
* Standard argument processing for cap module
*
* entry
* obj_state, argc, argv - Standard command arguments
* argstate - Address of ARGSTATE block to be initialized
*
* exit:
* On success, *argstate is initialized. On error,
* an error is issued and this routine does not return.
*/
static void
process_args(elfedit_obj_state_t *obj_state, int argc, const char *argv[],
ARGSTATE *argstate)
{
elfedit_getopt_state_t getopt_state;
elfedit_getopt_ret_t *getopt_ret;
bzero(argstate, sizeof (*argstate));
argstate->obj_state = obj_state;
elfedit_getopt_init(&getopt_state, &argc, &argv);
/* Add each new option to the options mask */
while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL)
argstate->optmask |= getopt_ret->gor_idmask;
/* If there may be an arbitrary amount of output, use a pager */
if (argc == 0)
elfedit_pager_init();
/* Return the updated values of argc/argv */
argstate->argc = argc;
argstate->argv = argv;
/* Locate the capabilities section */
argstate->cap.sec = elfedit_sec_getcap(obj_state, &argstate->cap.data,
&argstate->cap.num);
}
/*
* Print ELF capabilities values, taking the calling command, and output style
* into account.
*
* entry:
* cmd - CAP_CMD_T_* value giving identify of caller
* autoprint - If True, output is only produced if the elfedit
* autoprint flag is set. If False, output is always produced.
* argstate - Argument state block
* print_type - Specifies which capabilities elements to display.
* ndx = If print_type is PRINT_CAP_T_NDX, displays the index specified.
* Otherwise ignored.
*/
typedef enum {
PRINT_CAP_T_ALL = 0, /* Show all indexes */
PRINT_CAP_T_NDX = 1, /* Show capabilities[arg] only */
PRINT_CAP_T_TAG = 2 /* Show all elts with tag type */
/* given by arg */
} PRINT_CAP_T;
static void
print_cap(CAP_CMD_T cmd, int autoprint, ARGSTATE *argstate,
PRINT_CAP_T print_type, Word arg)
{
elfedit_outstyle_t outstyle;
Word cnt, ndx, printed = 0;
Cap *cap;
int header_done = 0;
Xword last_c_val = 0;
if (autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0))
return;
/*
* Pick an output style. cap:dump is required to use the default
* style. The other commands use the current output style.
*/
outstyle = (cmd == CAP_CMD_T_DUMP) ?
ELFEDIT_OUTSTYLE_DEFAULT : elfedit_outstyle();
/* How many elements do we examine? */
if (print_type == PRINT_CAP_T_NDX) {
if (arg >= argstate->cap.num)
return; /* Out of range */
ndx = arg;
cnt = 1;
} else {
ndx = 0;
cnt = argstate->cap.num;
}
cap = &argstate->cap.data[ndx];
for (; cnt--; cap++, ndx++) {
/*
* If we are only displaying certain tag types and
* this isn't one of those, move on to next element.
*/
if ((print_type == PRINT_CAP_T_TAG) && (cap->c_tag != arg))
continue;
if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) {
if (header_done == 0) {
header_done = 1;
Elf_cap_title(0);
}
Elf_cap_entry(NULL, cap, ndx,
argstate->obj_state->os_ehdr->e_machine);
} else {
/*
* In simple or numeric mode under a print type
* that is based on tag type rather than on index,
* quietly: If we've already printed this value,
* don't print it again. A common example of this
* is PRINT_CAP_T_RUNPATH when both CA_RPATH and
* CA_RUNPATH are present with the same value.
*/
if ((print_type == PRINT_CAP_T_TAG) && printed &&
(last_c_val == cap->c_un.c_val))
continue;
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
union {
Conv_cap_val_hw1_buf_t hw1;
Conv_cap_val_sf1_buf_t sf1;
} c_buf;
switch (cap->c_tag) {
case CA_SUNW_HW_1:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_cap_val_hw1(cap->c_un.c_val,
argstate->obj_state->os_ehdr->
e_machine,
CONV_FMT_NOBKT, &c_buf.hw1));
printed = 1;
continue;
case CA_SUNW_SF_1:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_cap_val_sf1(cap->c_un.c_val,
argstate->obj_state->os_ehdr->
e_machine,
CONV_FMT_NOBKT, &c_buf.sf1));
printed = 1;
continue;
}
}
elfedit_printf(MSG_ORIG(MSG_FMT_HEXXWORDNL),
cap->c_un.c_val);
}
printed = 1;
last_c_val = cap->c_un.c_val;
}
/*
* If nothing was output under the print types that are
* based on tag type, issue an error saying it doesn't exist.
*/
if (!printed && (print_type == PRINT_CAP_T_TAG)) {
Conv_inv_buf_t inv_buf;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOCAELT),
EC_WORD(argstate->cap.sec->sec_shndx),
argstate->cap.sec->sec_name, conv_cap_tag(arg, &inv_buf));
}
}
/*
* Process the elt argument: This will be a tag type if -capndx is
* not present and this is a print request. It will be an index otherwise.
*
* entry:
* argstate - Argument state block
* arg - Argument string to be converted into an index
* argname - String giving the name by which the argument is
* referred in the online help for the command.
* print_request - True if the command is to print the current
* value(s) and return without changing anything.
* print_type - Address of variable containing PRINT_CAP_T_
* code specifying how the elements will be displayed.
*
* exit:
* If print_request is False: arg is converted into an integer value.
* If -capndx was used, we convert it into an integer. If it was not
* used, then arg is a tag name --- we find the first capabilities entry
* that matches. If no entry matches, and there is an extra CA_NULL,
* it is added. Otherwise an error is issued. *print_type is set
* to PRINT_CAP_T_NDX.
*
* If print_request is True: If -capndx was used, arg is converted into
* an integer value, *print_type is set to PRINT_CAP_T_NDX, and
* the value is returned. If -capndx was not used, *print_type is set to
* PRINT_CAP_T_TAG, and the tag value is returned.
*/
static Word
arg_to_index(ARGSTATE *argstate, const char *arg, const char *argname,
int print_request, PRINT_CAP_T *print_type)
{
Word ndx, ca_value;
/* Assume we are returning an index, alter as needed below */
*print_type = PRINT_CAP_T_NDX;
/* If -capndx was used, this is a simple numeric index */
if ((argstate->optmask & CAP_OPT_F_CAPNDX) != 0)
return ((Word) elfedit_atoui_range(arg, argname, 0,
argstate->cap.num - 1, NULL));
/* The argument is a CA_ tag type, not a numeric index */
ca_value = (Word) elfedit_atoconst(arg, ELFEDIT_CONST_CA);
/*
* If this is a printing request, then we let print_cap() show
* all the items with this tag type.
*/
if (print_request) {
*print_type = PRINT_CAP_T_TAG;
return (ca_value);
}
/* Locate the first entry with the given tag type */
for (ndx = 0; ndx < argstate->cap.num; ndx++) {
if (argstate->cap.data[ndx].c_tag == ca_value) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_CA2NDX),
EC_WORD(argstate->cap.sec->sec_shndx),
argstate->cap.sec->sec_name, EC_WORD(ndx), arg);
return (ndx);
}
}
/* No room to create one, so we're out of options and must fail */
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOCAELT),
EC_WORD(argstate->cap.sec->sec_shndx),
argstate->cap.sec->sec_name, arg);
/*NOTREACHED*/
return (0); /* For lint */
}
/*
* Argument processing for the bitmask commands. Convert the arguments
* to integer form, apply -and/-cmp/-or, and return the resulting value.
*
* entry:
* argstate - Argument state block
* orig - Value of original bitmask
* const_sym - NULL, or array of name->integer mappings for
* applicable symbolic constant names.
*/
static Word
flag_bitop(ARGSTATE *argstate, Word orig, const elfedit_atoui_sym_t *const_sym)
{
Word flags = 0;
int i;
/* Collect the arguments */
for (i = 0; i < argstate->argc; i++)
flags |= (Word) elfedit_atoui(argstate->argv[i], const_sym);
/* Complement the value? */
if (argstate->optmask & CAP_OPT_F_CMP)
flags = ~flags;
/* Perform any requested bit operations */
if (argstate->optmask & CAP_OPT_F_AND)
flags &= orig;
else if (argstate->optmask & CAP_OPT_F_OR)
flags |= orig;
return (flags);
}
/*
* Common body for the cap: module commands. These commands
* share a large amount of common behavior, so it is convenient
* to centralize things and use the cmd argument to handle the
* small differences.
*
* entry:
* cmd - One of the CAP_CMD_T_* constants listed above, specifying
* which command to implement.
* obj_state, argc, argv - Standard command arguments
*/
static elfedit_cmdret_t
cmd_body(CAP_CMD_T cmd, elfedit_obj_state_t *obj_state,
int argc, const char *argv[])
{
ARGSTATE argstate;
Cap *cap;
const char *cap_name;
Word cap_ndx, cap_num;
elfedit_cmdret_t ret = ELFEDIT_CMDRET_NONE;
PRINT_CAP_T print_type = PRINT_CAP_T_ALL;
Word ndx;
int print_only = 0;
int do_autoprint = 1;
/* Process the optional arguments */
process_args(obj_state, argc, argv, &argstate);
cap = argstate.cap.data;
cap_num = argstate.cap.num;
cap_name = argstate.cap.sec->sec_name;
cap_ndx = argstate.cap.sec->sec_shndx;
/* Check number of arguments, gather information */
switch (cmd) {
case CAP_CMD_T_DUMP:
/* cap:dump can accept an optional index argument */
if (argstate.argc > 1)
elfedit_command_usage();
print_only = 1;
if (argstate.argc == 1)
ndx = arg_to_index(&argstate, argstate.argv[0],
MSG_ORIG(MSG_STR_ELT), print_only, &print_type);
break;
case CAP_CMD_T_TAG:
case CAP_CMD_T_VALUE:
print_only = (argstate.argc != 2);
if (argstate.argc > 0) {
if (argstate.argc > 2)
elfedit_command_usage();
ndx = arg_to_index(&argstate, argstate.argv[0],
MSG_ORIG(MSG_STR_ELT), print_only, &print_type);
}
break;
case CAP_CMD_T_DELETE:
if ((argstate.argc < 1) || (argstate.argc > 2))
elfedit_command_usage();
ndx = arg_to_index(&argstate, argstate.argv[0],
MSG_ORIG(MSG_STR_ELT),
0, &print_type);
do_autoprint = 0;
break;
case CAP_CMD_T_MOVE:
if ((argstate.argc < 2) || (argstate.argc > 3))
elfedit_command_usage();
ndx = arg_to_index(&argstate, argstate.argv[0],
MSG_ORIG(MSG_STR_ELT), 0, &print_type);
do_autoprint = 0;
break;
case CAP_CMD_T_HW1:
print_only = (argstate.argc == 0);
ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str(
ELFEDIT_CONST_CA, CA_SUNW_HW_1, 1),
MSG_ORIG(MSG_STR_VALUE), print_only, &print_type);
break;
case CAP_CMD_T_SF1:
print_only = (argstate.argc == 0);
ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str(
ELFEDIT_CONST_CA, CA_SUNW_SF_1, 1),
MSG_ORIG(MSG_STR_VALUE), print_only, &print_type);
break;
default:
/* Note expected: All commands should have been caught above */
elfedit_command_usage();
break;
}
/* If this is a request to print current values, do it and return */
if (print_only) {
print_cap(cmd, 0, &argstate, print_type, ndx);
return (ELFEDIT_CMDRET_NONE);
}
switch (cmd) {
/*
* CAP_CMD_T_DUMP can't get here: It is a print-only
* command.
*/
case CAP_CMD_T_TAG:
{
Conv_inv_buf_t inv_buf1, inv_buf2;
Word c_tag = (Word) elfedit_atoconst(argstate.argv[1],
ELFEDIT_CONST_CA);
if (cap[ndx].c_tag == c_tag) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_S_OK),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_tag(c_tag, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_S_CHG),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_tag(cap[ndx].c_tag, &inv_buf1),
conv_cap_tag(c_tag, &inv_buf2));
cap[ndx].c_tag = c_tag;
ret = ELFEDIT_CMDRET_MOD;
}
}
break;
case CAP_CMD_T_VALUE:
{
Xword c_val = (Xword)
elfedit_atoui(argstate.argv[1], NULL);
if (cap[ndx].c_un.c_val == c_val) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_X_OK),
argstate.cap.sec->sec_shndx,
argstate.cap.sec->sec_name,
EC_WORD(ndx), EC_XWORD(c_val));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_X_CHG),
argstate.cap.sec->sec_shndx,
argstate.cap.sec->sec_name,
EC_WORD(ndx), EC_XWORD(cap[ndx].c_un.c_val),
EC_XWORD(c_val));
cap[ndx].c_un.c_val = c_val;
ret = ELFEDIT_CMDRET_MOD;
}
}
break;
case CAP_CMD_T_DELETE:
{
Word cnt = (argstate.argc == 1) ? 1 :
(Word) elfedit_atoui_range(argstate.argv[1],
MSG_ORIG(MSG_STR_COUNT), 1, cap_num - ndx, NULL);
const char *msg_prefix =
elfedit_sec_msgprefix(argstate.cap.sec);
elfedit_array_elts_delete(msg_prefix, argstate.cap.data,
sizeof (Cap), cap_num, ndx, cnt);
ret = ELFEDIT_CMDRET_MOD;
}
break;
case CAP_CMD_T_MOVE:
{
Cap save;
Word cnt;
Word dstndx;
const char *msg_prefix =
elfedit_sec_msgprefix(argstate.cap.sec);
dstndx = (Word)
elfedit_atoui_range(argstate.argv[1],
MSG_ORIG(MSG_STR_DST_INDEX), 0, cap_num - 1,
NULL);
if (argstate.argc == 2) {
cnt = 1;
} else {
cnt = (Word) elfedit_atoui_range(
argstate.argv[2], MSG_ORIG(MSG_STR_COUNT),
1, cap_num, NULL);
}
elfedit_array_elts_move(msg_prefix, argstate.cap.data,
sizeof (save), cap_num, ndx, dstndx, cnt, &save);
ret = ELFEDIT_CMDRET_MOD;
}
break;
case CAP_CMD_T_HW1:
{
Conv_cap_val_hw1_buf_t buf1, buf2;
Half mach = argstate.obj_state->os_ehdr->e_machine;
Xword hw1;
hw1 = flag_bitop(&argstate, cap[ndx].c_un.c_val,
elfedit_mach_sunw_hw1_to_atoui(mach));
/* Set the value */
if (cap[ndx].c_un.c_val == hw1) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_BSB_OK), cap_ndx,
cap_name, EC_WORD(ndx),
conv_cap_val_hw1(cap[ndx].c_un.c_val, mach,
CONV_FMT_NOBKT, &buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_BSB_CHG),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_val_hw1(cap[ndx].c_un.c_val, mach,
CONV_FMT_NOBKT, &buf1),
conv_cap_val_hw1(hw1, mach,
CONV_FMT_NOBKT, &buf2));
ret = ELFEDIT_CMDRET_MOD;
cap[ndx].c_un.c_val = hw1;
}
}
break;
case CAP_CMD_T_SF1:
{
Conv_cap_val_sf1_buf_t buf1, buf2;
Half mach = argstate.obj_state->os_ehdr->e_machine;
Xword sf1;
sf1 = flag_bitop(&argstate, cap[ndx].c_un.c_val,
elfedit_const_to_atoui(ELFEDIT_CONST_SF1_SUNW));
/* Set the value */
if (cap[ndx].c_un.c_val == sf1) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_BSB_OK), cap_ndx,
cap_name, EC_WORD(ndx),
conv_cap_val_sf1(cap[ndx].c_un.c_val, mach,
CONV_FMT_NOBKT, &buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_BSB_CHG),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_val_sf1(cap[ndx].c_un.c_val, mach,
CONV_FMT_NOBKT, &buf1),
conv_cap_val_sf1(sf1, mach,
CONV_FMT_NOBKT, &buf2));
ret = ELFEDIT_CMDRET_MOD;
cap[ndx].c_un.c_val = sf1;
}
}
break;
}
/*
* If we modified the capabilities section header, tell libelf.
*/
if (ret == ELFEDIT_CMDRET_MOD)
elfedit_modified_data(argstate.cap.sec);
/* Do autoprint */
if (do_autoprint)
print_cap(cmd, 1, &argstate, print_type, ndx);
return (ret);
}
/*
* Command completion functions for the commands
*/
/*
* Command completion for the first argument, which specifies
* the capabilities element to use. Examines the options to see if
* -capndx is present, and if not, supplies the completion
* strings for argument 1.
*/
/*ARGSUSED*/
static void
cpl_eltarg(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
Word i;
/* Make sure it's the first argument */
if ((argc - num_opt) != 1)
return;
/* Is -capndx present? If so, we don't complete tag types */
for (i = 0; i < num_opt; i++)
if (strcmp(argv[i], MSG_ORIG(MSG_STR_MINUS_CAPNDX)) == 0)
return;
/*
* Supply capability tag names. There are very few of these, so
* rather than worry about whether a given tag exists in the
* file or not, we simply serve up all the possibilities.
*/
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_CA);
}
/*ARGSUSED*/
static void
cpl_tag(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/* First argument */
if ((argc - num_opt) == 1) {
cpl_eltarg(obj_state, cpldata, argc, argv, num_opt);
return;
}
/* The second argument is always a tag value */
if ((argc - num_opt) == 2)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_CA);
}
/*ARGSUSED*/
static void
cpl_hw1(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
elfedit_atoui_sym_t *sym_const;
/* This routine allows multiple flags to be specified */
/*
* If there is no object, then supply all the hardware
* capabilities we know of.
*/
if (obj_state == NULL) {
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_AV_386);
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_AV_SPARC);
return;
}
/*
* Supply the hardware capabilities for the type of
* machine the object is for, if we know any.
*/
sym_const = elfedit_mach_sunw_hw1_to_atoui(
obj_state->os_ehdr->e_machine);
if (sym_const != NULL)
elfedit_cpl_atoui(cpldata, sym_const);
}
/*ARGSUSED*/
static void
cpl_sf1(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/* This routine allows multiple flags to be specified */
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SF1_SUNW);
}
/*
* Implementation functions for the commands
*/
static elfedit_cmdret_t
cmd_dump(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_DUMP, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_tag(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_TAG, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_value(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_VALUE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_delete(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_DELETE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_move(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_MOVE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_hw1(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_HW1, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_sf1(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(CAP_CMD_T_SF1, obj_state, argc, argv));
}
/*ARGSUSED*/
elfedit_module_t *
elfedit_init(elfedit_module_version_t version)
{
/* For commands that only accept -and, -cmp, -o, and -or */
static elfedit_cmd_optarg_t opt_ostyle_bitop[] = {
{ ELFEDIT_STDOA_OPT_AND, NULL,
ELFEDIT_CMDOA_F_INHERIT, CAP_OPT_F_AND, CAP_OPT_F_OR },
{ ELFEDIT_STDOA_OPT_CMP, NULL,
ELFEDIT_CMDOA_F_INHERIT, CAP_OPT_F_CMP, 0 },
{ ELFEDIT_STDOA_OPT_O, NULL,
ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
{ ELFEDIT_STDOA_OPT_OR, NULL,
ELFEDIT_CMDOA_F_INHERIT, CAP_OPT_F_OR, CAP_OPT_F_AND },
{ NULL }
};
/* For commands that only accept -capndx */
static elfedit_cmd_optarg_t opt_capndx[] = {
{ MSG_ORIG(MSG_STR_MINUS_CAPNDX),
/* MSG_INTL(MSG_OPTDESC_CAPNDX) */
ELFEDIT_I18NHDL(MSG_OPTDESC_CAPNDX), 0,
CAP_OPT_F_CAPNDX, 0 },
{ NULL }
};
/* For commands thataccept -capndx and output styles */
static elfedit_cmd_optarg_t opt_ostyle_capndx[] = {
{ MSG_ORIG(MSG_STR_MINUS_CAPNDX),
/* MSG_INTL(MSG_OPTDESC_CAPNDX) */
ELFEDIT_I18NHDL(MSG_OPTDESC_CAPNDX), 0,
CAP_OPT_F_CAPNDX, 0 },
{ ELFEDIT_STDOA_OPT_O, NULL,
ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
{ NULL }
};
/* cap:dump */
static const char *name_dump[] = {
MSG_ORIG(MSG_CMD_DUMP),
MSG_ORIG(MSG_STR_EMPTY), /* "" makes this the default command */
NULL
};
static elfedit_cmd_optarg_t arg_dump[] = {
{ MSG_ORIG(MSG_STR_ELT),
/* MSG_INTL(MSG_ARGDESC_ELT) */
ELFEDIT_I18NHDL(MSG_ARGDESC_ELT),
ELFEDIT_CMDOA_F_OPT },
{ NULL }
};
/* cap:tag */
static const char *name_tag[] = { MSG_ORIG(MSG_CMD_TAG), NULL };
static elfedit_cmd_optarg_t arg_tag[] = {
{ MSG_ORIG(MSG_STR_ELT),
/* MSG_INTL(MSG_A1_TAG_ELT) */
ELFEDIT_I18NHDL(MSG_A1_TAG_ELT),
ELFEDIT_CMDOA_F_OPT },
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_A2_TAG_VALUE) */
ELFEDIT_I18NHDL(MSG_A2_TAG_VALUE),
ELFEDIT_CMDOA_F_OPT },
{ NULL }
};
/* cap:value */
static const char *name_value[] = { MSG_ORIG(MSG_CMD_VALUE), NULL };
static elfedit_cmd_optarg_t arg_value[] = {
{ MSG_ORIG(MSG_STR_ELT),
/* MSG_INTL(MSG_ARGDESC_ELT) */
ELFEDIT_I18NHDL(MSG_ARGDESC_ELT),
ELFEDIT_CMDOA_F_OPT },
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_A2_VALUE_VALUE) */
ELFEDIT_I18NHDL(MSG_A2_VALUE_VALUE),
ELFEDIT_CMDOA_F_OPT },
{ NULL }
};
/* cap:delete */
static const char *name_delete[] = { MSG_ORIG(MSG_CMD_DELETE), NULL };
static elfedit_cmd_optarg_t arg_delete[] = {
{ MSG_ORIG(MSG_STR_ELT),
/* MSG_INTL(MSG_ARGDESC_ELT) */
ELFEDIT_I18NHDL(MSG_ARGDESC_ELT),
0 },
{ MSG_ORIG(MSG_STR_COUNT),
/* MSG_INTL(MSG_A2_DELETE_COUNT) */
ELFEDIT_I18NHDL(MSG_A2_DELETE_COUNT),
ELFEDIT_CMDOA_F_OPT },
{ NULL }
};
/* cap:move */
static const char *name_move[] = { MSG_ORIG(MSG_CMD_MOVE), NULL };
static elfedit_cmd_optarg_t arg_move[] = {
{ MSG_ORIG(MSG_STR_ELT),
/* MSG_INTL(MSG_ARGDESC_ELT) */
ELFEDIT_I18NHDL(MSG_ARGDESC_ELT),
0 },
{ MSG_ORIG(MSG_STR_DST_INDEX),
/* MSG_INTL(MSG_A2_MOVE_DST_INDEX) */
ELFEDIT_I18NHDL(MSG_A2_MOVE_DST_INDEX),
0 },
{ MSG_ORIG(MSG_STR_COUNT),
/* MSG_INTL(MSG_A3_MOVE_COUNT) */
ELFEDIT_I18NHDL(MSG_A3_MOVE_COUNT),
ELFEDIT_CMDOA_F_OPT },
{ NULL }
};
/* cap:hw1 */
static const char *name_hw1[] = { MSG_ORIG(MSG_CMD_HW1), NULL };
static elfedit_cmd_optarg_t arg_hw1[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_A1_HW1_VALUE) */
ELFEDIT_I18NHDL(MSG_A1_HW1_VALUE),
ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
{ NULL }
};
/* cap:sf1 */
static const char *name_sf1[] = { MSG_ORIG(MSG_CMD_SF1), NULL };
static elfedit_cmd_optarg_t arg_sf1[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_A1_SF1_VALUE) */
ELFEDIT_I18NHDL(MSG_A1_SF1_VALUE),
ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
{ NULL }
};
static elfedit_cmd_t cmds[] = {
/* cap:dump */
{ cmd_dump, cpl_eltarg, name_dump,
/* MSG_INTL(MSG_DESC_DUMP) */
ELFEDIT_I18NHDL(MSG_DESC_DUMP),
/* MSG_INTL(MSG_HELP_DUMP) */
ELFEDIT_I18NHDL(MSG_HELP_DUMP),
opt_capndx, arg_dump },
/* cap:tag */
{ cmd_tag, cpl_tag, name_tag,
/* MSG_INTL(MSG_DESC_TAG) */
ELFEDIT_I18NHDL(MSG_DESC_TAG),
/* MSG_INTL(MSG_HELP_TAG) */
ELFEDIT_I18NHDL(MSG_HELP_TAG),
opt_ostyle_capndx, arg_tag },
/* cap:value */
{ cmd_value, cpl_eltarg, name_value,
/* MSG_INTL(MSG_DESC_VALUE) */
ELFEDIT_I18NHDL(MSG_DESC_VALUE),
/* MSG_INTL(MSG_HELP_VALUE) */
ELFEDIT_I18NHDL(MSG_HELP_VALUE),
opt_ostyle_capndx, arg_value },
/* cap:delete */
{ cmd_delete, cpl_eltarg, name_delete,
/* MSG_INTL(MSG_DESC_DELETE) */
ELFEDIT_I18NHDL(MSG_DESC_DELETE),
/* MSG_INTL(MSG_HELP_DELETE) */
ELFEDIT_I18NHDL(MSG_HELP_DELETE),
opt_capndx, arg_delete },
/* cap:move */
{ cmd_move, cpl_eltarg, name_move,
/* MSG_INTL(MSG_DESC_MOVE) */
ELFEDIT_I18NHDL(MSG_DESC_MOVE),
/* MSG_INTL(MSG_HELP_MOVE) */
ELFEDIT_I18NHDL(MSG_HELP_MOVE),
opt_capndx, arg_move },
/* cap:hw1 */
{ cmd_hw1, cpl_hw1, name_hw1,
/* MSG_INTL(MSG_DESC_HW1) */
ELFEDIT_I18NHDL(MSG_DESC_HW1),
/* MSG_INTL(MSG_HELP_HW1) */
ELFEDIT_I18NHDL(MSG_HELP_HW1),
opt_ostyle_bitop, arg_hw1 },
/* cap:sf1 */
{ cmd_sf1, cpl_sf1, name_sf1,
/* MSG_INTL(MSG_DESC_SF1) */
ELFEDIT_I18NHDL(MSG_DESC_SF1),
/* MSG_INTL(MSG_HELP_SF1) */
ELFEDIT_I18NHDL(MSG_HELP_SF1),
opt_ostyle_bitop, arg_sf1 },
{ NULL }
};
static elfedit_module_t module = {
ELFEDIT_VER_CURRENT, MSG_ORIG(MSG_MOD_NAME),
/* MSG_INTL(MSG_MOD_DESC) */
ELFEDIT_I18NHDL(MSG_MOD_DESC),
cmds, mod_i18nhdl_to_str };
return (&module);
}