/*
* 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 <ctype.h>
#include <elfedit.h>
#include <sys/elf_SPARC.h>
#include <sys/elf_amd64.h>
#include <strings.h>
#include <conv.h>
#include <debug.h>
#include <ehdr_msg.h>
/*
* This module handles changes to the ELF header
*/
/*
* 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 ELF header */
EHDR_CMD_T_DUMP = 0, /* ehdr:dump */
/* Commands that correspond directly to ELF header fields */
EHDR_CMD_T_E_IDENT = 1, /* ehdr:e_ident */
EHDR_CMD_T_E_TYPE = 2, /* ehdr:e_type */
EHDR_CMD_T_E_MACHINE = 3, /* ehdr:e_machine */
EHDR_CMD_T_E_VERSION = 4, /* ehdr:e_version */
EHDR_CMD_T_E_ENTRY = 5, /* ehdr:e_entry */
EHDR_CMD_T_E_PHOFF = 6, /* ehdr:e_phoff */
EHDR_CMD_T_E_SHOFF = 7, /* ehdr:e_shoff */
EHDR_CMD_T_E_FLAGS = 8, /* ehdr:e_flags */
EHDR_CMD_T_E_EHSIZE = 9, /* ehdr:e_ehsize */
EHDR_CMD_T_E_PHENTSIZE = 10, /* ehdr:e_phentsize */
EHDR_CMD_T_E_PHNUM = 11, /* ehdr:e_phnum */
EHDR_CMD_T_E_SHENTSIZE = 12, /* ehdr:e_shentsize */
EHDR_CMD_T_E_SHNUM = 13, /* ehdr:e_shnum */
EHDR_CMD_T_E_SHSTRNDX = 14, /* ehdr:e_shstrndx */
/* Commands that correspond to the e_ident[] array in ELF hdr */
EHDR_CMD_T_EI_MAG0 = 15, /* ehdr:ei_mag0 */
EHDR_CMD_T_EI_MAG1 = 16, /* ehdr:ei_mag1 */
EHDR_CMD_T_EI_MAG2 = 17, /* ehdr:ei_mag2 */
EHDR_CMD_T_EI_MAG3 = 18, /* ehdr:ei_mag3 */
EHDR_CMD_T_EI_CLASS = 19, /* ehdr:ei_class */
EHDR_CMD_T_EI_DATA = 20, /* ehdr:ei_data */
EHDR_CMD_T_EI_VERSION = 21, /* ehdr:ei_version */
EHDR_CMD_T_EI_OSABI = 22, /* ehdr:ei_osabi */
EHDR_CMD_T_EI_ABIVERSION = 23 /* ehdr:ei_abiversion */
} EHDR_CMD_T;
#ifndef _ELF64
/*
* We supply this function for the msg module
*/
const char *
_ehdr_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 ehdr_opt_t enum specifies a bit value for every optional
* argument allowed by a command in this module.
*/
typedef enum {
EHDR_OPT_F_AND = 1, /* -and: AND (&) values to dest */
EHDR_OPT_F_CMP = 2, /* -cmp: Complement (~) values */
EHDR_OPT_F_OR = 4, /* -or: OR (|) values to dest */
EHDR_OPT_F_SHNDX = 8, /* -shndx: sec argument is index of */
/* section, not name */
EHDR_OPT_F_SHTYP = 16 /* -shtyp: sec argument is type of */
/* section, not name */
} ehdr_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;
ehdr_opt_t optmask; /* Mask of options used */
int argc; /* # of plain arguments */
const char **argv; /* Plain arguments */
} ARGSTATE;
/*
* Standard argument processing for ehdr 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;
}
/*
* Format the given magic number byte into a buffer
*
* entry:
* value - Value of the magic value byte given by
* ehdr->ei_ident[EI_MAG?]
*/
static const char *
conv_magic_value(int value)
{
/*
* This routine can be called twice within a single C statement,
* so we use alternating buffers on each call to allow this
* without requiring the caller to supply a buffer (the size of
* which they don't know).
*/
static char buf1[20];
static char buf2[20];
static char *buf;
/* Switch buffers */
buf = (buf == buf1) ? buf2 : buf1;
if (isprint(value))
(void) snprintf(buf, sizeof (buf1),
MSG_ORIG(MSG_FMT_HEXNUM_QCHR), value, value);
else
(void) snprintf(buf, sizeof (buf1),
MSG_ORIG(MSG_FMT_HEXNUM), value);
return (buf);
}
/*
* Print ELF header values, taking the calling command, and output style
* into account.
*
* entry:
* cmd - EHDR_CMD_T_* value giving identify of caller
* e_ident_ndx - Ignored unless cmd is EHDR_CMD_T_E_IDENT. In IDENT
* case, index of item in e_ident[] array to display, or
* -1 to display the entire array.
* autoprint - If True, output is only produced if the elfedit
* autoprint flag is set. If False, output is always produced.
* argstate - Argument state block
*/
static void
print_ehdr(EHDR_CMD_T cmd, int e_ident_ndx, int autoprint,
ARGSTATE *argstate)
{
elfedit_outstyle_t outstyle;
Conv_fmt_flags_t flags_fmt_flags = 0;
Ehdr *ehdr;
int c;
Conv_inv_buf_t inv_buf;
if (autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0))
return;
/*
* Pick an output style. ehdr:dump is required to use the default
* style. The other commands use the current output style.
*/
if (cmd == EHDR_CMD_T_DUMP) {
outstyle = ELFEDIT_OUTSTYLE_DEFAULT;
} else {
outstyle = elfedit_outstyle();
/*
* When the caller specifies the simple output style,
* omit the brackets from around the values.
*/
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
flags_fmt_flags = CONV_FMT_NOBKT;
/*
* For things that show a single header item, switch
* from default to simple mode.
*/
if ((outstyle == ELFEDIT_OUTSTYLE_DEFAULT) &&
((cmd != EHDR_CMD_T_E_IDENT) || (e_ident_ndx != -1)))
outstyle = ELFEDIT_OUTSTYLE_SIMPLE;
}
ehdr = argstate->obj_state->os_ehdr;
/*
* If doing default output, use elfdump style where we
* show the full ELF header. In this case, the command
* that called us doesn't matter. This can only happen
* from ehdr:dump or ehdr:e_ident/
*/
if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) {
const char *ndx, *value;
char ndx_buf[64], value_buf[20];
int i;
if (cmd == EHDR_CMD_T_DUMP) {
Elf_ehdr(NULL, ehdr,
argstate->obj_state->os_secarr[0].sec_shdr);
elfedit_printf(MSG_ORIG(MSG_STR_NL));
}
/*
* Elf_ehdr() does not display all of e_ident[], so we
* augment by displaying the entire array separately.
*/
elfedit_printf(MSG_ORIG(MSG_STR_EIDENT_HDR));
for (i = 0; i < EI_NIDENT; i++) {
ndx = value = NULL;
switch (i) {
case EI_MAG0:
case EI_MAG1:
case EI_MAG2:
case EI_MAG3:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, i, 1);
value = conv_magic_value(ehdr->e_ident[i]);
break;
case EI_CLASS:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_CLASS, 1);
value = conv_ehdr_class(ehdr->e_ident[EI_CLASS],
0, &inv_buf);
break;
case EI_DATA:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_DATA, 1);
value = conv_ehdr_data(ehdr->e_ident[EI_DATA],
0, &inv_buf);
break;
case EI_VERSION:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_VERSION, 1);
value = conv_ehdr_vers(
ehdr->e_ident[EI_VERSION], 0, &inv_buf);
break;
case EI_OSABI:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_OSABI, 1);
value = conv_ehdr_osabi(ehdr->e_ident[EI_OSABI],
0, &inv_buf);
break;
case EI_ABIVERSION:
ndx = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_ABIVERSION, 1);
value = conv_ehdr_abivers(
ehdr->e_ident[EI_OSABI],
ehdr->e_ident[EI_ABIVERSION],
CONV_FMT_DECIMAL, &inv_buf);
break;
default:
value = value_buf;
(void) snprintf(value_buf, sizeof (value_buf),
MSG_ORIG(MSG_FMT_HEXNUM), ehdr->e_ident[i]);
break;
}
if (ndx == NULL)
(void) snprintf(ndx_buf, sizeof (ndx_buf),
MSG_ORIG(MSG_FMT_BKTINT), i);
else
(void) snprintf(ndx_buf, sizeof (ndx_buf),
MSG_ORIG(MSG_FMT_BKTSTR), ndx);
elfedit_printf(MSG_ORIG(MSG_FMT_EI_ELT),
ndx_buf, value);
}
return;
}
switch (cmd) {
case EHDR_CMD_T_E_IDENT:
{
int i, cnt;
/* Show one element, or the entire thing? */
if (e_ident_ndx == -1) {
i = 0;
cnt = EI_NIDENT;
} else {
i = e_ident_ndx;
cnt = 1;
}
for (; cnt-- > 0; i++) {
/*
* If using numeric style, or there is
* no conversion routine for this item,
* print a simple hex value.
*/
if ((outstyle == ELFEDIT_OUTSTYLE_NUM) ||
(i > EI_ABIVERSION)) {
elfedit_printf(
MSG_ORIG(MSG_FMT_HEXNUMNL),
ehdr->e_ident[i]);
continue;
}
/* Handle special cases in simple mode */
switch (i) {
case EI_MAG0:
case EI_MAG1:
case EI_MAG2:
case EI_MAG3:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_magic_value(ehdr->e_ident[i]));
continue;
case EI_CLASS:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_class(
ehdr->e_ident[EI_CLASS], 0,
&inv_buf));
continue;
case EI_DATA:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_data(
ehdr->e_ident[EI_DATA], 0,
&inv_buf));
continue;
case EI_VERSION:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_vers(
ehdr->e_ident[EI_VERSION], 0,
&inv_buf));
continue;
case EI_OSABI:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_osabi(
ehdr->e_ident[EI_OSABI], 0,
&inv_buf));
continue;
case EI_ABIVERSION:
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_abivers(
ehdr->e_ident[EI_OSABI],
ehdr->e_ident[EI_ABIVERSION],
CONV_FMT_DECIMAL, &inv_buf));
continue;
}
}
}
return;
case EHDR_CMD_T_E_TYPE:
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_type(ehdr->e_ident[EI_OSABI],
ehdr->e_type, 0, &inv_buf));
else
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
ehdr->e_type);
return;
case EHDR_CMD_T_E_MACHINE:
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_mach(ehdr->e_machine, 0, &inv_buf));
} else {
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(ehdr->e_machine));
}
return;
case EHDR_CMD_T_E_VERSION:
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_vers(ehdr->e_version, 0, &inv_buf));
else
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
ehdr->e_version);
return;
case EHDR_CMD_T_E_ENTRY:
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
EC_WORD(ehdr->e_entry));
return;
case EHDR_CMD_T_E_PHOFF:
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
EC_WORD(ehdr->e_phoff));
return;
case EHDR_CMD_T_E_SHOFF:
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
EC_WORD(ehdr->e_shoff));
return;
case EHDR_CMD_T_E_FLAGS:
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
Conv_ehdr_flags_buf_t flags_buf;
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_flags(ehdr->e_machine, ehdr->e_flags,
flags_fmt_flags, &flags_buf));
} else {
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
ehdr->e_flags);
}
return;
case EHDR_CMD_T_E_EHSIZE:
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(ehdr->e_ehsize));
return;
case EHDR_CMD_T_E_PHENTSIZE:
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(ehdr->e_phentsize));
return;
case EHDR_CMD_T_E_PHNUM:
{
Word num = ehdr->e_phnum;
/*
* If using extended indexes, fetch the real
* value from shdr[0].sh_info
*/
if (num == PN_XNUM)
num = argstate->obj_state->
os_secarr[0].sec_shdr->sh_info;
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(num));
}
return;
case EHDR_CMD_T_E_SHENTSIZE:
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(ehdr->e_shentsize));
return;
case EHDR_CMD_T_E_SHNUM:
{
Word num = ehdr->e_shnum;
/*
* If using extended indexes, fetch the real
* value from shdr[0].sh_size
*/
if (num == 0)
num = argstate->obj_state->
os_secarr[0].sec_shdr->sh_size;
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(num));
}
return;
case EHDR_CMD_T_E_SHSTRNDX:
{
Word num = ehdr->e_shstrndx;
/*
* If using extended indexes, fetch the real
* value from shdr[0].sh_link
*/
if (num == SHN_XINDEX)
num = argstate->obj_state->
os_secarr[0].sec_shdr->sh_link;
elfedit_printf(MSG_ORIG(MSG_FMT_DECNUMNL),
EC_WORD(num));
}
return;
case EHDR_CMD_T_EI_MAG0:
case EHDR_CMD_T_EI_MAG1:
case EHDR_CMD_T_EI_MAG2:
case EHDR_CMD_T_EI_MAG3:
/* This depends on EHDR_CMD_T_EI_MAG[0-3] being contiguous */
c = ehdr->e_ident[cmd - EHDR_CMD_T_EI_MAG0];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_magic_value(c));
else
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL), c);
return;
case EHDR_CMD_T_EI_CLASS:
c = ehdr->e_ident[EI_CLASS];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_class(c, 0, &inv_buf));
else
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL), c);
return;
case EHDR_CMD_T_EI_DATA:
c = ehdr->e_ident[EI_DATA];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_data(c, 0, &inv_buf));
else
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL), c);
return;
case EHDR_CMD_T_EI_VERSION:
c = ehdr->e_ident[EI_VERSION];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_vers(c, 0, &inv_buf));
else
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL), c);
return;
case EHDR_CMD_T_EI_OSABI:
c = ehdr->e_ident[EI_OSABI];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_osabi(c, 0, &inv_buf));
} else {
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
EC_WORD(c));
}
return;
case EHDR_CMD_T_EI_ABIVERSION:
c = ehdr->e_ident[EI_ABIVERSION];
if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
conv_ehdr_abivers(ehdr->e_ident[EI_OSABI],
c, CONV_FMT_DECIMAL, &inv_buf));
} else {
elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
EC_WORD(c));
}
return;
}
}
/*
* Common body for the ehdr: 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 EHDR_CMD_T_* constants listed above, specifying
* which command to implement.
* obj_state, argc, argv - Standard command arguments
*/
static elfedit_cmdret_t
cmd_body(EHDR_CMD_T cmd, elfedit_obj_state_t *obj_state,
int argc, const char *argv[])
{
/*
* When a call comes in for ehdr:e_ident[ndx], and the
* specified element is one that we have a special command
* for, then we revector to that special command instead
* of using the generic ehdr:e_ident processing. This array,
* which is indexed by the e_ident[] index value is used
* to decide if that is the case. If the resulting value
* is EHDR_CMD_T_E_IDENT, then the generic processing is
* used. Otherwise, we revector to the specified command.
*/
static const int e_ident_revector[16] = {
EHDR_CMD_T_EI_MAG0, /* 0: EI_MAG0 */
EHDR_CMD_T_EI_MAG1, /* 1: EI_MAG1 */
EHDR_CMD_T_EI_MAG2, /* 2: EI_MAG2 */
EHDR_CMD_T_EI_MAG3, /* 3: EI_MAG3 */
EHDR_CMD_T_EI_CLASS, /* 4: EI_CLASS */
EHDR_CMD_T_EI_DATA, /* 5: EI_DATA */
EHDR_CMD_T_EI_VERSION, /* 6: EI_VERSION */
EHDR_CMD_T_EI_OSABI, /* 7: EI_OSABI */
EHDR_CMD_T_EI_ABIVERSION, /* 8: EI_ABIVERSION */
EHDR_CMD_T_E_IDENT, /* 9: generic */
EHDR_CMD_T_E_IDENT, /* 10: generic */
EHDR_CMD_T_E_IDENT, /* 11: generic */
EHDR_CMD_T_E_IDENT, /* 12: generic */
EHDR_CMD_T_E_IDENT, /* 13: generic */
EHDR_CMD_T_E_IDENT, /* 14: generic */
EHDR_CMD_T_E_IDENT, /* 15: generic */
};
ARGSTATE argstate;
Ehdr *ehdr;
elfedit_cmdret_t ret = ELFEDIT_CMDRET_NONE;
int e_ident_ndx = -1;
Conv_inv_buf_t inv_buf1, inv_buf2;
/* Process the optional arguments */
process_args(obj_state, argc, argv, &argstate);
/* Check number of arguments */
switch (cmd) {
case EHDR_CMD_T_DUMP:
/* ehdr:dump does not accept arguments */
if (argstate.argc > 0)
elfedit_command_usage();
break;
case EHDR_CMD_T_E_IDENT:
/*
* ehdr:e_ident accepts 1 or 2 arguments, the first
* being the index into the array, and the second being
* the value. If there are arguments, then process the
* index, and remove it from the argument list.
*/
if (argstate.argc > 0) {
if (argstate.argc > 2)
elfedit_command_usage();
e_ident_ndx = (int)
elfedit_atoconst_range(argstate.argv[0],
MSG_ORIG(MSG_STR_INDEX), 0, EI_NIDENT - 1,
ELFEDIT_CONST_EI);
argstate.argc--;
argstate.argv++;
/*
* If the index is for one of the e_ident elements
* that we have a special command for, then switch
* to that command. e_ident_revector[] returns
* EHDR_CMD_T_E_IDENT in the cases where such a command
* does not exist, in which case we'll continue with the
* generic code.
*/
cmd = e_ident_revector[e_ident_ndx];
}
break;
case EHDR_CMD_T_E_FLAGS:
/* ehdr:e_flags accepts an arbitrary number of arguments */
break;
default:
/* The remaining commands accept a single optional argument */
if (argstate.argc > 1)
elfedit_command_usage();
break;
}
/* If there are no arguments, dump the ELF header and return */
if (argstate.argc == 0) {
print_ehdr(cmd, e_ident_ndx, 0, &argstate);
return (ELFEDIT_CMDRET_NONE);
}
ehdr = obj_state->os_ehdr;
switch (cmd) {
/*
* EHDR_CMD_T_DUMP can't get here: It never has an
* argument, and is handled above.
*/
case EHDR_CMD_T_E_IDENT:
{
/*
* Only those e_ident[] elements for which we
* don't have a specialized command come here.
* The argument is a value to be set in
* e_ident[e_ident_ndx].
*/
uchar_t value = (uchar_t)
elfedit_atoui_range(argstate.argv[0],
MSG_ORIG(MSG_STR_VALUE), 0, 255, NULL);
if (ehdr->e_ident[e_ident_ndx] == value) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_D_X_OK),
e_ident_ndx, EC_WORD(value));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_D_X_CHG),
e_ident_ndx, ehdr->e_ident[e_ident_ndx],
value);
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[e_ident_ndx] = value;
}
}
break;
case EHDR_CMD_T_E_TYPE:
{
/* The argument gives the object type */
Half type = (Half) elfedit_atoconst(argstate.argv[0],
ELFEDIT_CONST_ET);
const char *name = MSG_ORIG(MSG_CMD_E_TYPE);
if (ehdr->e_type == type) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_OK), name,
conv_ehdr_type(ehdr->e_ident[EI_OSABI],
ehdr->e_type, 0, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_CHG), name,
conv_ehdr_type(ehdr->e_ident[EI_OSABI],
ehdr->e_type, 0, &inv_buf1),
conv_ehdr_type(ehdr->e_ident[EI_OSABI],
type, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_type = type;
}
}
break;
case EHDR_CMD_T_E_MACHINE:
{
/* The argument gives the machine code */
Half mach = (Half) elfedit_atoconst(argstate.argv[0],
ELFEDIT_CONST_EM);
const char *name = MSG_ORIG(MSG_CMD_E_MACHINE);
if (ehdr->e_machine == mach) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_OK), name,
conv_ehdr_mach(ehdr->e_machine, 0,
&inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_CHG), name,
conv_ehdr_mach(ehdr->e_machine, 0,
&inv_buf1),
conv_ehdr_mach(mach, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD_OS_MACH;
ehdr->e_machine = mach;
}
}
break;
case EHDR_CMD_T_E_VERSION:
{
/* The argument gives the version */
Word ver = (Word) elfedit_atoconst(argstate.argv[0],
ELFEDIT_CONST_EV);
const char *name = MSG_ORIG(MSG_CMD_E_VERSION);
if (ehdr->e_version == ver) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_OK), name,
conv_ehdr_vers(ehdr->e_version, 0,
&inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_CHG), name,
conv_ehdr_vers(ehdr->e_version, 0,
&inv_buf1),
conv_ehdr_vers(ver, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_version = ver;
}
}
break;
case EHDR_CMD_T_E_ENTRY:
{
/* The argument gives the entry address */
Addr entry = (Addr)
elfedit_atoui(argstate.argv[0], NULL);
const char *name = MSG_ORIG(MSG_CMD_E_ENTRY);
if (ehdr->e_entry == entry) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_OK), name,
EC_ADDR(ehdr->e_entry));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_CHG), name,
EC_ADDR(ehdr->e_entry), EC_ADDR(entry));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_entry = entry;
}
}
break;
case EHDR_CMD_T_E_PHOFF:
{
/* The argument gives the program header offset */
Off off = (Off) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_PHOFF);
if (ehdr->e_phoff == off) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_OK), name,
EC_OFF(ehdr->e_phoff));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_CHG), name,
EC_OFF(ehdr->e_phoff), EC_OFF(off));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_phoff = off;
}
}
break;
case EHDR_CMD_T_E_SHOFF:
{
/* The argument gives the section header offset */
Off off = (Off) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_SHOFF);
if (ehdr->e_shoff == off) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_OK), name,
EC_OFF(ehdr->e_shoff));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_LLX_CHG), name,
EC_OFF(ehdr->e_shoff), EC_OFF(off));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_shoff = off;
}
}
break;
case EHDR_CMD_T_E_FLAGS:
{
Conv_ehdr_flags_buf_t flags_buf1, flags_buf2;
const char *name = MSG_ORIG(MSG_CMD_E_FLAGS);
Word flags = 0;
int i;
/* Collect the arguments */
for (i = 0; i < argstate.argc; i++)
flags |= (Word)
elfedit_atoconst(argstate.argv[i],
ELFEDIT_CONST_EF);
/* Complement the value? */
if (argstate.optmask & EHDR_OPT_F_CMP)
flags = ~flags;
/* Perform any requested bit operations */
if (argstate.optmask & EHDR_OPT_F_AND)
flags &= ehdr->e_flags;
else if (argstate.optmask & EHDR_OPT_F_OR)
flags |= ehdr->e_flags;
/* Set the value */
if (ehdr->e_flags == flags) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_OK), name,
conv_ehdr_flags(ehdr->e_machine,
ehdr->e_flags, 0, &flags_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_S_CHG), name,
conv_ehdr_flags(ehdr->e_machine,
ehdr->e_flags, 0, &flags_buf1),
conv_ehdr_flags(ehdr->e_machine,
flags, 0, &flags_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_flags = flags;
}
}
break;
case EHDR_CMD_T_E_EHSIZE:
{
/* The argument gives the ELF header size */
Half ehsize = (Half) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_EHSIZE);
if (ehdr->e_ehsize == ehsize) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_ehsize));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_ehsize), EC_WORD(ehsize));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ehsize = ehsize;
}
}
break;
case EHDR_CMD_T_E_PHENTSIZE:
{
/*
* The argument gives the size of a program
* header element.
*/
Half phentsize = (Half) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_PHENTSIZE);
if (ehdr->e_phentsize == phentsize) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_phentsize));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_phentsize),
EC_WORD(phentsize));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_phentsize = phentsize;
}
}
break;
case EHDR_CMD_T_E_PHNUM:
{
/* The argument gives the number of program headers */
Word phnum = (Word) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_PHNUM);
elfedit_section_t *sec0 = &obj_state->os_secarr[0];
Shdr *shdr0 = sec0->sec_shdr;
Half e_phnum;
Word sh_info;
if (phnum >= PN_XNUM) {
e_phnum = PN_XNUM;
sh_info = phnum;
} else {
e_phnum = phnum;
sh_info = 0;
}
if (ehdr->e_phnum == e_phnum) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_phnum));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_phnum), e_phnum);
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_phnum = e_phnum;
}
if (shdr0->sh_info == sh_info) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_OK),
MSG_ORIG(MSG_STR_SH_INFO),
EC_WORD(shdr0->sh_info));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_CHG),
MSG_ORIG(MSG_STR_SH_INFO),
EC_WORD(shdr0->sh_info), sh_info);
ret = ELFEDIT_CMDRET_MOD;
shdr0->sh_info = sh_info;
elfedit_modified_shdr(sec0);
}
}
break;
case EHDR_CMD_T_E_SHENTSIZE:
{
/*
* The argument gives the size of a program
* header element.
*/
Half shentsize = (Half) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_SHENTSIZE);
if (ehdr->e_shentsize == shentsize) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_shentsize));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_shentsize),
EC_WORD(shentsize));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_shentsize = shentsize;
}
}
break;
case EHDR_CMD_T_E_SHNUM:
{
/* The argument gives the number of section headers */
Word shnum = (Word) elfedit_atoui(argstate.argv[0],
NULL);
const char *name = MSG_ORIG(MSG_CMD_E_SHNUM);
elfedit_section_t *sec0 = &obj_state->os_secarr[0];
Shdr *shdr0 = sec0->sec_shdr;
Half e_shnum;
Word sh_size;
if (shnum >= SHN_LORESERVE) {
e_shnum = 0;
sh_size = shnum;
} else {
e_shnum = shnum;
sh_size = 0;
}
if (ehdr->e_shnum == e_shnum) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_shnum));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_shnum), e_shnum);
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_shnum = e_shnum;
}
if (shdr0->sh_size == sh_size) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_OK),
MSG_ORIG(MSG_STR_SH_SIZE),
EC_WORD(shdr0->sh_size));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_CHG),
MSG_ORIG(MSG_STR_SH_SIZE),
EC_WORD(shdr0->sh_size), sh_size);
ret = ELFEDIT_CMDRET_MOD;
shdr0->sh_size = sh_size;
elfedit_modified_shdr(sec0);
}
}
break;
case EHDR_CMD_T_E_SHSTRNDX:
{
const char *name = MSG_ORIG(MSG_CMD_E_SHSTRNDX);
Word shstrndx;
elfedit_section_t *sec0 = &obj_state->os_secarr[0];
Shdr *shdr0 = sec0->sec_shdr;
Half e_shstrndx;
Word sh_link;
/*
* By default, sec argument is name of section.
* If -shndx is used, it is a numeric index, and
* if -shtyp is used, it is a section type.
*/
if (argstate.optmask & EHDR_OPT_F_SHNDX)
shstrndx = elfedit_atoshndx(argstate.argv[0],
obj_state->os_shnum);
else if (argstate.optmask & EHDR_OPT_F_SHTYP)
shstrndx = elfedit_type_to_shndx(obj_state,
elfedit_atoconst(argstate.argv[0],
ELFEDIT_CONST_SHT));
else
shstrndx = elfedit_name_to_shndx(obj_state,
argstate.argv[0]);
/* Warn if the section isn't a string table */
if ((shstrndx >= obj_state->os_shnum) ||
((shstrndx >= SHN_LORESERVE) &&
(shstrndx <= SHN_HIRESERVE)) ||
(obj_state->os_secarr[shstrndx].sec_shdr->sh_type !=
SHT_STRTAB))
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_NOTSTRTAB), name,
EC_WORD(shstrndx));
if (shstrndx >= SHN_LORESERVE) {
e_shstrndx = SHN_XINDEX;
sh_link = shstrndx;
} else {
e_shstrndx = shstrndx;
sh_link = 0;
}
if (ehdr->e_shstrndx == e_shstrndx) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_OK), name,
EC_WORD(ehdr->e_shstrndx));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_E_D_CHG), name,
EC_WORD(ehdr->e_shstrndx), e_shstrndx);
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_shstrndx = e_shstrndx;
}
if (shdr0->sh_link == sh_link) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_OK),
MSG_ORIG(MSG_STR_SH_LINK),
EC_WORD(shdr0->sh_link));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_SHDR0_D_CHG),
MSG_ORIG(MSG_STR_SH_LINK),
EC_WORD(shdr0->sh_link), sh_link);
ret = ELFEDIT_CMDRET_MOD;
shdr0->sh_link = sh_link;
elfedit_modified_shdr(sec0);
}
}
break;
case EHDR_CMD_T_EI_MAG0:
case EHDR_CMD_T_EI_MAG1:
case EHDR_CMD_T_EI_MAG2:
case EHDR_CMD_T_EI_MAG3:
{
/*
* This depends on EHDR_CMD_T_EI_MAG[0-3]
* being contiguous
*/
int ei_ndx = (cmd - EHDR_CMD_T_EI_MAG0) + EI_MAG0;
/* The argument gives the magic number byte */
int mag = (int)elfedit_atoui_range(argstate.argv[0],
MSG_ORIG(MSG_STR_VALUE), 0, 255, NULL);
if (ehdr->e_ident[ei_ndx] == mag) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK),
elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, ei_ndx, 1),
conv_magic_value(ehdr->e_ident[ei_ndx]));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG),
elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, ei_ndx, 1),
conv_magic_value(ehdr->e_ident[ei_ndx]),
conv_magic_value(mag));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[ei_ndx] = mag;
}
}
break;
case EHDR_CMD_T_EI_CLASS:
{
/* The argument gives the ELFCLASS value */
int class = (int)elfedit_atoconst_range(
argstate.argv[0], MSG_ORIG(MSG_STR_VALUE), 0, 255,
ELFEDIT_CONST_ELFCLASS);
const char *name = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_CLASS, 1);
if (ehdr->e_ident[EI_CLASS] == class) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK), name,
conv_ehdr_class(class, 0, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG), name,
conv_ehdr_class(ehdr->e_ident[EI_CLASS],
0, &inv_buf1),
conv_ehdr_class(class, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[EI_CLASS] = class;
}
}
break;
case EHDR_CMD_T_EI_DATA:
{
/* The argument gives the ELFDATA value */
int data = (int)elfedit_atoconst_range(argstate.argv[0],
MSG_ORIG(MSG_STR_VALUE), 0, 255,
ELFEDIT_CONST_ELFDATA);
const char *name = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_DATA, 1);
if (ehdr->e_ident[EI_DATA] == data) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK), name,
conv_ehdr_data(data, 0, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG), name,
conv_ehdr_data(ehdr->e_ident[EI_DATA],
0, &inv_buf1),
conv_ehdr_data(data, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[EI_DATA] = data;
}
}
break;
case EHDR_CMD_T_EI_VERSION:
{
/* The argument gives the version */
int ver = (int)elfedit_atoconst_range(argstate.argv[0],
MSG_ORIG(MSG_STR_VALUE), 0, 255, ELFEDIT_CONST_EV);
const char *name = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_VERSION, 1);
if (ehdr->e_ident[EI_VERSION] == ver) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK), name,
conv_ehdr_vers(ver, 0, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG), name,
conv_ehdr_vers(ehdr->e_ident[EI_VERSION],
0, &inv_buf1),
conv_ehdr_vers(ver, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[EI_VERSION] = ver;
}
}
break;
case EHDR_CMD_T_EI_OSABI:
{
/* The argument gives the ABI code */
int osabi = (int)elfedit_atoconst_range(
argstate.argv[0], MSG_ORIG(MSG_STR_VALUE), 0, 255,
ELFEDIT_CONST_ELFOSABI);
const char *name = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_OSABI, 1);
if (ehdr->e_ident[EI_OSABI] == osabi) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK), name,
conv_ehdr_osabi(osabi, 0, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG), name,
conv_ehdr_osabi(ehdr->e_ident[EI_OSABI],
0, &inv_buf1),
conv_ehdr_osabi(osabi, 0, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD_OS_MACH;
ehdr->e_ident[EI_OSABI] = osabi;
}
}
break;
case EHDR_CMD_T_EI_ABIVERSION:
{
/* The argument gives the ABI version */
int abiver = (int)elfedit_atoconst_range(
argstate.argv[0], MSG_ORIG(MSG_STR_VALUE), 0, 255,
ELFEDIT_CONST_EAV);
const char *name = elfedit_atoconst_value_to_str(
ELFEDIT_CONST_EI, EI_ABIVERSION, 1);
if (ehdr->e_ident[EI_ABIVERSION] == abiver) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_OK), name,
conv_ehdr_abivers(ehdr->e_ident[EI_OSABI],
abiver, CONV_FMT_DECIMAL, &inv_buf1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EI_S_S_CHG), name,
conv_ehdr_abivers(ehdr->e_ident[EI_OSABI],
ehdr->e_ident[EI_ABIVERSION],
CONV_FMT_DECIMAL, &inv_buf1),
conv_ehdr_abivers(ehdr->e_ident[EI_OSABI],
abiver, CONV_FMT_DECIMAL, &inv_buf2));
ret = ELFEDIT_CMDRET_MOD;
ehdr->e_ident[EI_ABIVERSION] = abiver;
}
}
break;
}
/*
* If we modified the ELF header, tell libelf.
*/
if (ret == ELFEDIT_CMDRET_MOD)
elfedit_modified_ehdr(obj_state);
/* Do autoprint */
print_ehdr(cmd, e_ident_ndx, 1, &argstate);
return (ret);
}
/*
* Command completion functions for the various commands
*/
/*ARGSUSED*/
static void
cpl_e_ident(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
elfedit_atoui_t ndx;
/*
* 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) {
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EI);
return;
}
if (argc != 2)
return;
/*
* In order to offer up the right completion strings for
* the value, we need to know what index was given for
* the first argument. If we don't recognize the index,
* we want to return quietly without issuing an error,
* so we use elfedit_atoui_range2(), which returns
* a success/failure result and does not throw any errors.
*/
if (elfedit_atoconst_range2(argv[0], 0, EI_NIDENT - 1,
ELFEDIT_CONST_EI, &ndx) == 0)
return;
switch (ndx) {
case EI_CLASS:
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFCLASS);
break;
case EI_DATA:
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFDATA);
break;
case EI_VERSION:
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EV);
break;
case EI_OSABI:
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFOSABI);
break;
}
}
/*ARGSUSED*/
static void
cpl_e_type(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ET);
}
/*ARGSUSED*/
static void
cpl_e_machine(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EM);
}
/*ARGSUSED*/
static void
cpl_e_version(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EV);
}
/*ARGSUSED*/
static void
cpl_e_flags(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_EF);
}
/*ARGSUSED*/
static void
cpl_e_shstrndx(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
enum { NAME, INDEX, TYPE } op;
Word ndx;
/*
* The plainargument can be a section name, index, or
* type, based on the options used. All have completions.
*/
if (argc != (num_opt + 1))
return;
op = NAME;
for (ndx = 0; ndx < num_opt; ndx++) {
if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHNDX)) == 0)
op = INDEX;
else if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHTYP)) == 0)
op = TYPE;
}
if (obj_state == NULL) { /* No object available */
if (op == TYPE)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
return;
}
/*
* Loop over the sections and supply command completion
* for the string tables in the file.
*/
for (ndx = 0; ndx < obj_state->os_shnum; ndx++) {
elfedit_section_t *sec = &obj_state->os_secarr[ndx];
if (sec->sec_shdr->sh_type != SHT_STRTAB)
continue;
switch (op) {
case NAME:
elfedit_cpl_match(cpldata, sec->sec_name, 0);
break;
case INDEX:
elfedit_cpl_ndx(cpldata, ndx);
break;
case TYPE:
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT_STRTAB);
break;
}
}
}
/*ARGSUSED*/
static void
cpl_ei_class(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFCLASS);
}
/*ARGSUSED*/
static void
cpl_ei_data(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFDATA);
}
/*ARGSUSED*/
static void
cpl_ei_osabi(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_ELFOSABI);
}
/*ARGSUSED*/
static void
cpl_ei_abiversion(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
const char *argv[], int num_opt)
{
/*
* 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)
elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EAV);
}
/*
* 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(EHDR_CMD_T_DUMP, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_ident(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_IDENT, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_type(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_TYPE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_machine(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_MACHINE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_version(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_VERSION, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_entry(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_ENTRY, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_phoff(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_PHOFF, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_shoff(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_SHOFF, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_flags(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_FLAGS, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_ehsize(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_EHSIZE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_phentsize(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_PHENTSIZE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_phnum(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_PHNUM, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_shentsize(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_SHENTSIZE, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_shnum(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_SHNUM, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_e_shstrndx(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_E_SHSTRNDX, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_mag0(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_MAG0, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_mag1(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_MAG1, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_mag2(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_MAG2, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_mag3(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_MAG3, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_class(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_CLASS, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_data(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_DATA, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_version(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_VERSION, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_osabi(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_OSABI, obj_state, argc, argv));
}
static elfedit_cmdret_t
cmd_ei_abiversion(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
return (cmd_body(EHDR_CMD_T_EI_ABIVERSION, obj_state, argc, argv));
}
/*ARGSUSED*/
elfedit_module_t *
elfedit_init(elfedit_module_version_t version)
{
/* Many of the commands only accept -o */
static elfedit_cmd_optarg_t opt_std[] = {
{ ELFEDIT_STDOA_OPT_O, NULL,
ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
{ NULL }
};
/* ehdr:dump */
static const char *name_dump[] = {
MSG_ORIG(MSG_CMD_DUMP),
MSG_ORIG(MSG_STR_EMPTY), /* "" makes this the default command */
NULL
};
/* ehdr:e_ident */
static const char *name_e_ident[] = {
MSG_ORIG(MSG_CMD_E_IDENT), NULL };
static elfedit_cmd_optarg_t arg_e_ident[] = {
{ MSG_ORIG(MSG_STR_INDEX),
/* MSG_INTL(MSG_ARGDESC_E_IDENT_NDX) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_IDENT_NDX),
ELFEDIT_CMDOA_F_OPT, 0 },
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_IDENT_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_IDENT_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_type */
static const char *name_e_type[] = {
MSG_ORIG(MSG_CMD_E_TYPE), NULL };
static elfedit_cmd_optarg_t arg_e_type[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_TYPE_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_TYPE_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_machine */
static const char *name_e_machine[] = {
MSG_ORIG(MSG_CMD_E_MACHINE), NULL };
static elfedit_cmd_optarg_t arg_e_machine[] = {
{ MSG_ORIG(MSG_STR_TYPE),
/* MSG_INTL(MSG_ARGDESC_E_MACHINE_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_MACHINE_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_version */
static const char *name_e_version[] = {
MSG_ORIG(MSG_CMD_E_VERSION), NULL };
static elfedit_cmd_optarg_t arg_e_version[] = {
{ MSG_ORIG(MSG_STR_VERSION),
/* MSG_INTL(MSG_ARGDESC_E_VERSION_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_VERSION_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_entry */
static const char *name_e_entry[] = {
MSG_ORIG(MSG_CMD_E_ENTRY), NULL };
static elfedit_cmd_optarg_t arg_e_entry[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_ENTRY_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_ENTRY_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_phoff */
static const char *name_e_phoff[] = {
MSG_ORIG(MSG_CMD_E_PHOFF), NULL };
static elfedit_cmd_optarg_t arg_e_phoff[] = {
{ MSG_ORIG(MSG_STR_OFFSET),
/* MSG_INTL(MSG_ARGDESC_E_PHOFF_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_PHOFF_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_shoff */
static const char *name_e_shoff[] = {
MSG_ORIG(MSG_CMD_E_SHOFF), NULL };
static elfedit_cmd_optarg_t arg_e_shoff[] = {
{ MSG_ORIG(MSG_STR_OFFSET),
/* MSG_INTL(MSG_ARGDESC_E_SHOFF_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_SHOFF_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_flags */
static const char *name_e_flags[] = {
MSG_ORIG(MSG_CMD_E_FLAGS), NULL };
static elfedit_cmd_optarg_t opt_e_flags[] = {
{ ELFEDIT_STDOA_OPT_AND, NULL,
ELFEDIT_CMDOA_F_INHERIT, EHDR_OPT_F_AND, EHDR_OPT_F_OR },
{ ELFEDIT_STDOA_OPT_CMP, NULL,
ELFEDIT_CMDOA_F_INHERIT, EHDR_OPT_F_CMP, 0 },
{ ELFEDIT_STDOA_OPT_O, NULL,
ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
{ ELFEDIT_STDOA_OPT_OR, NULL,
ELFEDIT_CMDOA_F_INHERIT, EHDR_OPT_F_OR, EHDR_OPT_F_AND },
{ NULL }
};
static elfedit_cmd_optarg_t arg_e_flags[] = {
{ MSG_ORIG(MSG_STR_FLAGVALUE),
/* MSG_INTL(MSG_ARGDESC_E_FLAGS_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_FLAGS_VALUE),
ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT, 0 },
{ NULL }
};
/* ehdr:e_ehsize */
static const char *name_e_ehsize[] = {
MSG_ORIG(MSG_CMD_E_EHSIZE), NULL };
static elfedit_cmd_optarg_t arg_e_ehsize[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_EHSIZE_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_EHSIZE_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_phentsize */
static const char *name_e_phentsize[] = {
MSG_ORIG(MSG_CMD_E_PHENTSIZE), NULL };
static elfedit_cmd_optarg_t arg_e_phentsize[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_PHENTSIZE_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_PHENTSIZE_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_phnum */
static const char *name_e_phnum[] = {
MSG_ORIG(MSG_CMD_E_PHNUM), NULL };
static elfedit_cmd_optarg_t arg_e_phnum[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_PHNUM_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_PHNUM_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_shentsize */
static const char *name_e_shentsize[] = {
MSG_ORIG(MSG_CMD_E_SHENTSIZE), NULL };
static elfedit_cmd_optarg_t arg_e_shentsize[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_SHENTSIZE_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_SHENTSIZE_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_shnum */
static const char *name_e_shnum[] = {
MSG_ORIG(MSG_CMD_E_SHNUM), NULL };
static elfedit_cmd_optarg_t arg_e_shnum[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_E_SHNUM_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_SHNUM_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:e_shstrndx */
static const char *name_e_shstrndx[] = {
MSG_ORIG(MSG_CMD_E_SHSTRNDX), NULL };
static elfedit_cmd_optarg_t opt_e_shstrndx[] = {
{ ELFEDIT_STDOA_OPT_O, NULL,
ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
/* MSG_INTL(MSG_OPTDESC_SHNDX) */
ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
EHDR_OPT_F_SHNDX, EHDR_OPT_F_SHTYP },
{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
/* MSG_INTL(MSG_OPTDESC_SHTYP) */
ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
EHDR_OPT_F_SHTYP, EHDR_OPT_F_SHNDX, },
{ NULL }
};
static elfedit_cmd_optarg_t arg_e_shstrndx[] = {
{ MSG_ORIG(MSG_STR_SEC),
/* MSG_INTL(MSG_ARGDESC_E_SHSTRNDX_SEC) */
ELFEDIT_I18NHDL(MSG_ARGDESC_E_SHSTRNDX_SEC),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_mag0 */
static const char *name_ei_mag0[] = {
MSG_ORIG(MSG_CMD_EI_MAG0), NULL };
static elfedit_cmd_optarg_t arg_ei_mag0[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_MAG0_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_MAG0_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_mag1 */
static const char *name_ei_mag1[] = {
MSG_ORIG(MSG_CMD_EI_MAG1), NULL };
static elfedit_cmd_optarg_t arg_ei_mag1[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_MAG1_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_MAG1_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_mag2 */
static const char *name_ei_mag2[] = {
MSG_ORIG(MSG_CMD_EI_MAG2), NULL };
static elfedit_cmd_optarg_t arg_ei_mag2[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_MAG2_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_MAG2_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_mag3 */
static const char *name_ei_mag3[] = {
MSG_ORIG(MSG_CMD_EI_MAG3), NULL };
static elfedit_cmd_optarg_t arg_ei_mag3[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_MAG3_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_MAG3_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_class */
static const char *name_ei_class[] = {
MSG_ORIG(MSG_CMD_EI_CLASS), NULL };
static elfedit_cmd_optarg_t arg_ei_class[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_CLASS_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_CLASS_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_data */
static const char *name_ei_data[] = {
MSG_ORIG(MSG_CMD_EI_DATA), NULL };
static elfedit_cmd_optarg_t arg_ei_data[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_DATA_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_DATA_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_version */
static const char *name_ei_version[] = {
MSG_ORIG(MSG_CMD_EI_VERSION), NULL };
/* Note: arg_e_version is also used for this command */
/* ehdr:ei_osabi */
static const char *name_ei_osabi[] = {
MSG_ORIG(MSG_CMD_EI_OSABI), NULL };
static elfedit_cmd_optarg_t arg_ei_osabi[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_OSABI_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_OSABI_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
/* ehdr:ei_abiversion */
static const char *name_ei_abiversion[] = {
MSG_ORIG(MSG_CMD_EI_ABIVERSION), NULL };
static elfedit_cmd_optarg_t arg_ei_abiversion[] = {
{ MSG_ORIG(MSG_STR_VALUE),
/* MSG_INTL(MSG_ARGDESC_EI_ABIVERSION_VALUE) */
ELFEDIT_I18NHDL(MSG_ARGDESC_EI_ABIVERSION_VALUE),
ELFEDIT_CMDOA_F_OPT, 0 },
{ NULL }
};
static elfedit_cmd_t cmds[] = {
/* ehdr:dump */
{ cmd_dump, NULL, name_dump,
/* MSG_INTL(MSG_DESC_DUMP) */
ELFEDIT_I18NHDL(MSG_DESC_DUMP),
/* MSG_INTL(MSG_HELP_DUMP) */
ELFEDIT_I18NHDL(MSG_HELP_DUMP),
NULL, NULL },
/* ehdr:e_ident */
{ cmd_e_ident, cpl_e_ident, name_e_ident,
/* MSG_INTL(MSG_DESC_E_IDENT) */
ELFEDIT_I18NHDL(MSG_DESC_E_IDENT),
/* MSG_INTL(MSG_HELP_E_IDENT) */
ELFEDIT_I18NHDL(MSG_HELP_E_IDENT),
opt_std, arg_e_ident },
/* ehdr:e_type */
{ cmd_e_type, cpl_e_type, name_e_type,
/* MSG_INTL(MSG_DESC_E_TYPE) */
ELFEDIT_I18NHDL(MSG_DESC_E_TYPE),
/* MSG_INTL(MSG_HELP_E_TYPE) */
ELFEDIT_I18NHDL(MSG_HELP_E_TYPE),
opt_std, arg_e_type },
/* ehdr:e_machine */
{ cmd_e_machine, cpl_e_machine, name_e_machine,
/* MSG_INTL(MSG_DESC_E_MACHINE) */
ELFEDIT_I18NHDL(MSG_DESC_E_MACHINE),
/* MSG_INTL(MSG_HELP_E_MACHINE) */
ELFEDIT_I18NHDL(MSG_HELP_E_MACHINE),
opt_std, arg_e_machine },
/* ehdr:e_version */
{ cmd_e_version, cpl_e_version, name_e_version,
/* MSG_INTL(MSG_DESC_E_VERSION) */
ELFEDIT_I18NHDL(MSG_DESC_E_VERSION),
/* MSG_INTL(MSG_HELP_E_VERSION) */
ELFEDIT_I18NHDL(MSG_HELP_E_VERSION),
opt_std, arg_e_version },
/* ehdr:e_entry */
{ cmd_e_entry, NULL, name_e_entry,
/* MSG_INTL(MSG_DESC_E_ENTRY) */
ELFEDIT_I18NHDL(MSG_DESC_E_ENTRY),
/* MSG_INTL(MSG_HELP_E_ENTRY) */
ELFEDIT_I18NHDL(MSG_HELP_E_ENTRY),
opt_std, arg_e_entry },
/* ehdr:e_phoff */
{ cmd_e_phoff, NULL, name_e_phoff,
/* MSG_INTL(MSG_DESC_E_PHOFF) */
ELFEDIT_I18NHDL(MSG_DESC_E_PHOFF),
/* MSG_INTL(MSG_HELP_E_PHOFF) */
ELFEDIT_I18NHDL(MSG_HELP_E_PHOFF),
opt_std, arg_e_phoff },
/* ehdr:e_shoff */
{ cmd_e_shoff, NULL, name_e_shoff,
/* MSG_INTL(MSG_DESC_E_SHOFF) */
ELFEDIT_I18NHDL(MSG_DESC_E_SHOFF),
/* MSG_INTL(MSG_HELP_E_SHOFF) */
ELFEDIT_I18NHDL(MSG_HELP_E_SHOFF),
opt_std, arg_e_shoff },
/* ehdr:e_flags */
{ cmd_e_flags, cpl_e_flags, name_e_flags,
/* MSG_INTL(MSG_DESC_E_FLAGS) */
ELFEDIT_I18NHDL(MSG_DESC_E_FLAGS),
/* MSG_INTL(MSG_HELP_E_FLAGS) */
ELFEDIT_I18NHDL(MSG_HELP_E_FLAGS),
opt_e_flags, arg_e_flags },
/* ehdr:e_ehsize */
{ cmd_e_ehsize, NULL, name_e_ehsize,
/* MSG_INTL(MSG_DESC_E_EHSIZE) */
ELFEDIT_I18NHDL(MSG_DESC_E_EHSIZE),
/* MSG_INTL(MSG_HELP_E_EHSIZE) */
ELFEDIT_I18NHDL(MSG_HELP_E_EHSIZE),
opt_std, arg_e_ehsize },
/* ehdr:e_phentsize */
{ cmd_e_phentsize, NULL, name_e_phentsize,
/* MSG_INTL(MSG_DESC_E_PHENTSIZE) */
ELFEDIT_I18NHDL(MSG_DESC_E_PHENTSIZE),
/* MSG_INTL(MSG_HELP_E_PHENTSIZE) */
ELFEDIT_I18NHDL(MSG_HELP_E_PHENTSIZE),
opt_std, arg_e_phentsize },
/* ehdr:e_phnum */
{ cmd_e_phnum, NULL, name_e_phnum,
/* MSG_INTL(MSG_DESC_E_PHNUM) */
ELFEDIT_I18NHDL(MSG_DESC_E_PHNUM),
/* MSG_INTL(MSG_HELP_E_PHNUM) */
ELFEDIT_I18NHDL(MSG_HELP_E_PHNUM),
opt_std, arg_e_phnum },
/* ehdr:e_shentsize */
{ cmd_e_shentsize, NULL, name_e_shentsize,
/* MSG_INTL(MSG_DESC_E_SHENTSIZE) */
ELFEDIT_I18NHDL(MSG_DESC_E_SHENTSIZE),
/* MSG_INTL(MSG_HELP_E_SHENTSIZE) */
ELFEDIT_I18NHDL(MSG_HELP_E_SHENTSIZE),
opt_std, arg_e_shentsize },
/* ehdr:e_shnum */
{ cmd_e_shnum, NULL, name_e_shnum,
/* MSG_INTL(MSG_DESC_E_SHNUM) */
ELFEDIT_I18NHDL(MSG_DESC_E_SHNUM),
/* MSG_INTL(MSG_HELP_E_SHNUM) */
ELFEDIT_I18NHDL(MSG_HELP_E_SHNUM),
opt_std, arg_e_shnum },
/* ehdr:e_shstrndx */
{ cmd_e_shstrndx, cpl_e_shstrndx, name_e_shstrndx,
/* MSG_INTL(MSG_DESC_E_SHSTRNDX) */
ELFEDIT_I18NHDL(MSG_DESC_E_SHSTRNDX),
/* MSG_INTL(MSG_HELP_E_SHSTRNDX) */
ELFEDIT_I18NHDL(MSG_HELP_E_SHSTRNDX),
opt_e_shstrndx, arg_e_shstrndx },
/* ehdr:ei_mag0 */
{ cmd_ei_mag0, NULL, name_ei_mag0,
/* MSG_INTL(MSG_DESC_EI_MAG0) */
ELFEDIT_I18NHDL(MSG_DESC_EI_MAG0),
/* MSG_INTL(MSG_HELP_EI_MAG0) */
ELFEDIT_I18NHDL(MSG_HELP_EI_MAG0),
opt_std, arg_ei_mag0 },
/* ehdr:ei_mag1 */
{ cmd_ei_mag1, NULL, name_ei_mag1,
/* MSG_INTL(MSG_DESC_EI_MAG1) */
ELFEDIT_I18NHDL(MSG_DESC_EI_MAG1),
/* MSG_INTL(MSG_HELP_EI_MAG1) */
ELFEDIT_I18NHDL(MSG_HELP_EI_MAG1),
opt_std, arg_ei_mag1 },
/* ehdr:ei_mag2 */
{ cmd_ei_mag2, NULL, name_ei_mag2,
/* MSG_INTL(MSG_DESC_EI_MAG2) */
ELFEDIT_I18NHDL(MSG_DESC_EI_MAG2),
/* MSG_INTL(MSG_HELP_EI_MAG2) */
ELFEDIT_I18NHDL(MSG_HELP_EI_MAG2),
opt_std, arg_ei_mag2 },
/* ehdr:ei_mag3 */
{ cmd_ei_mag3, NULL, name_ei_mag3,
/* MSG_INTL(MSG_DESC_EI_MAG3) */
ELFEDIT_I18NHDL(MSG_DESC_EI_MAG3),
/* MSG_INTL(MSG_HELP_EI_MAG3) */
ELFEDIT_I18NHDL(MSG_HELP_EI_MAG3),
opt_std, arg_ei_mag3 },
/* ehdr:ei_class */
{ cmd_ei_class, cpl_ei_class, name_ei_class,
/* MSG_INTL(MSG_DESC_EI_CLASS) */
ELFEDIT_I18NHDL(MSG_DESC_EI_CLASS),
/* MSG_INTL(MSG_HELP_EI_CLASS) */
ELFEDIT_I18NHDL(MSG_HELP_EI_CLASS),
opt_std, arg_ei_class },
/* ehdr:ei_data */
{ cmd_ei_data, cpl_ei_data, name_ei_data,
/* MSG_INTL(MSG_DESC_EI_DATA) */
ELFEDIT_I18NHDL(MSG_DESC_EI_DATA),
/* MSG_INTL(MSG_HELP_EI_DATA) */
ELFEDIT_I18NHDL(MSG_HELP_EI_DATA),
opt_std, arg_ei_data },
/* ehdr:ei_version */
{ cmd_ei_version, cpl_e_version, name_ei_version,
/* MSG_INTL(MSG_DESC_EI_VERSION) */
ELFEDIT_I18NHDL(MSG_DESC_EI_VERSION),
/* MSG_INTL(MSG_HELP_EI_VERSION) */
ELFEDIT_I18NHDL(MSG_HELP_EI_VERSION),
opt_std, arg_e_version },
/* ehdr:ei_osabi */
{ cmd_ei_osabi, cpl_ei_osabi, name_ei_osabi,
/* MSG_INTL(MSG_DESC_EI_OSABI) */
ELFEDIT_I18NHDL(MSG_DESC_EI_OSABI),
/* MSG_INTL(MSG_HELP_EI_OSABI) */
ELFEDIT_I18NHDL(MSG_HELP_EI_OSABI),
opt_std, arg_ei_osabi },
/* ehdr:ei_abiversion */
{ cmd_ei_abiversion, cpl_ei_abiversion, name_ei_abiversion,
/* MSG_INTL(MSG_DESC_EI_ABIVERSION) */
ELFEDIT_I18NHDL(MSG_DESC_EI_ABIVERSION),
/* MSG_INTL(MSG_HELP_EI_ABIVERSION) */
ELFEDIT_I18NHDL(MSG_HELP_EI_ABIVERSION),
opt_std, arg_ei_abiversion },
{ 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);
}