elfedit.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 <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <stdarg.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <dirent.h>
#include <libelf.h>
#include <gelf.h>
#include <conv.h>
#include <dlfcn.h>
#include <link.h>
#include <stdarg.h>
#include <libgen.h>
#include <libintl.h>
#include <locale.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <limits.h>
#include <strings.h>
#include <sgs.h>
#include "msg.h"
#include "_elfedit.h"
#include <debug.h> /* liblddb */
/*
* Column at which elfedit_format_command_usage() will wrap the
* generated usage string if the wrap argument is True (1).
*/
#define USAGE_WRAP_COL 55
/*
* Type used to represent a string buffer that can grow as needed
* to hold strings of arbitrary length. The user should declare
* variables of this type sa static. The strbuf_ensure_size() function
* is used to ensure that it has a minimum desired size.
*/
typedef struct {
char *buf; /* String buffer */
size_t n; /* Size of buffer */
} STRBUF;
/*
* Types used by tokenize_user_cmd() to represent the result of
* spliting a user command into individual tokens.
*/
typedef struct {
char *tok_str; /* Token string */
size_t tok_len; /* strlen(str) */
size_t tok_line_off; /* Token offset in original string */
} TOK_ELT;
typedef struct {
size_t tokst_cmd_len; /* Length of original user command, without */
/* newline or NULL termination chars */
size_t tokst_str_size; /* Space needed to hold all the resulting */
/* tokens, including terminating NULL */
TOK_ELT *tokst_buf; /* The array of tokens */
size_t tokst_cnt; /* # of tokens in array */
size_t tokst_bufsize; /* capacity of array */
} TOK_STATE;
/* State block used by gettok_init() and gettok() */
typedef struct {
const char *gtok_buf; /* Addr of buffer containing string */
char *gtok_cur_buf; /* Addr withing buffer for next token */
int gtok_inc_null_final; /* True if final NULL token used */
int gtok_null_seen; /* True when NULL byte seen */
TOK_ELT gtok_last_token; /* Last token parsed */
} GETTOK_STATE;
/*
* The elfedit_cpl_*() functions are used for command line completion.
* Currently this uses the tecla library, but to allow for changing the
* library used, we hide all tecla interfaces from our modules. Instead,
* cmd_match_fcn() builds an ELFEDIT_CPL_STATE struct, and we pass the
* address of that struct as an opaque handle to the modules. Since the
* pointer is opaque, the contents of ELFEDIT_CPL_STATE are free to change
* as necessary.
*/
typedef struct {
WordCompletion *ecpl_cpl; /* tecla handle */
const char *ecpl_line; /* raw input line */
int ecpl_word_start; /* start offset within line */
int ecpl_word_end; /* offset just past token */
/*
* ecpl_add_mod_colon is a secret handshake between
* elfedit_cpl_command() and elfedit_cpl_add_match(). It adds
* ':' to end of matched modules.
*/
int ecpl_add_mod_colon;
const char *ecpl_token_str; /* token being completed */
size_t ecpl_token_len; /* strlen(ecpl_token_str) */
} ELFEDIT_CPL_STATE;
/* This structure maintains elfedit global state */
STATE_T state;
/*
* Define a pair of static global variables that contain the
* ISA strings that correspond to %i and %I tokens in module search
* paths.
*
* isa_i_str - The ISA string for the currently running program
* isa_I_str - For 64-bit programs, the same as isa_i_str. For
* 32-bit programs, an empty string.
*/
#ifdef __sparc
#ifdef __sparcv9
static const char *isa_i_str = MSG_ORIG(MSG_ISA_SPARC_64);
static const char *isa_I_str = MSG_ORIG(MSG_ISA_SPARC_64);
#else
static const char *isa_i_str = MSG_ORIG(MSG_ISA_SPARC_32);
static const char *isa_I_str = MSG_ORIG(MSG_STR_EMPTY);
#endif
#endif
#ifdef __i386
static const char *isa_i_str = MSG_ORIG(MSG_ISA_X86_32);
static const char *isa_I_str = MSG_ORIG(MSG_STR_EMPTY);
#endif
#ifdef __amd64
static const char *isa_i_str = MSG_ORIG(MSG_ISA_X86_64);
static const char *isa_I_str = MSG_ORIG(MSG_ISA_X86_64);
#endif
/* Forward declarations */
static void free_user_cmds(void);
static void elfedit_pager_cleanup(void);
/*
* We supply this function for the msg module
*/
const char *
_elfedit_msg(Msg mid)
{
return (gettext(MSG_ORIG(mid)));
}
/*
* Copy at most min(cpsize, dstsize-1) bytes from src into dst,
* truncating src if necessary. The result is always null-terminated.
*
* entry:
* dst - Destination buffer
* src - Source string
* dstsize - sizeof(dst)
*
* note:
* This is similar to strncpy(), but with two modifications:
* 1) You specify the number of characters to copy, not just
* the size of the destination. Hence, you can copy non-NULL
* terminated strings.
* 2) The destination is guaranteed to be NULL terminated. strncpy()
* does not terminate a completely full buffer.
*/
static void
elfedit_strnbcpy(char *dst, const char *src, size_t cpsize, size_t dstsize)
{
if (cpsize >= dstsize)
cpsize = dstsize - 1;
if (cpsize > 0)
(void) strncpy(dst, src, cpsize + 1);
dst[cpsize] = '\0';
}
/*
* Calls exit() on behalf of elfedit.
*/
void
elfedit_exit(int status)
{
if (state.file.present) {
/* Exiting with unflushed changes pending? Issue debug notice */
if (state.file.dirty)
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_DIRTYEXIT));
/*
* If the edit file is marked for unlink on exit, then
* take care of it here.
*/
if (state.file.unlink_on_exit) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_UNLINKFILE),
state.file.outfile);
(void) unlink(state.file.outfile);
}
}
exit(status);
}
/*
* Standard message function for elfedit. All user visible
* output, for error or informational reasons, should go through
* this function.
*
* entry:
* type - Type of message. One of the ELFEDIT_MSG_* values.
* format, ... - As per the printf() family
*
* exit:
* The desired message has been output. For informational
* messages, control returns to the caller. For errors,
* this routine will terminate execution or strip the execution
* stack and return control directly to the outer control loop.
* In either case, the caller will not receive control.
*/
/*PRINTFLIKE2*/
void
elfedit_msg(elfedit_msg_t type, const char *format, ...)
{
typedef enum { /* What to do after finished */
DISP_RET = 0, /* Return to caller */
DISP_JMP = 1, /* if (interactive) longjmp else exit */
DISP_EXIT = 2 /* exit under all circumstances */
} DISP;
va_list args;
FILE *stream = stderr;
DISP disp = DISP_RET;
int do_output = 1;
int need_prefix = 1;
va_start(args, format);
switch (type) {
case ELFEDIT_MSG_ERR:
case ELFEDIT_MSG_CMDUSAGE:
disp = DISP_JMP;
break;
case ELFEDIT_MSG_FATAL:
disp = DISP_EXIT;
break;
case ELFEDIT_MSG_USAGE:
need_prefix = 0;
break;
case ELFEDIT_MSG_DEBUG:
if (!(state.flags & ELFEDIT_F_DEBUG))
return;
stream = stdout;
break;
case ELFEDIT_MSG_QUIET:
do_output = 0;
disp = DISP_JMP;
break;
}
/*
* If there is a pager process running, we are returning to the
* caller, and the output is going to stdout, then let the
* pager handle it instead of writing it directly from this process.
* That way, the output gets paged along with everything else.
*
* If there is a pager process running, and we are not returning
* to the caller, then end the pager process now, before we generate
* any new output. This allows for any text buffered in the pager
* pipe to be output before the new stuff.
*/
if (state.pager.fptr != NULL) {
if (disp == DISP_RET) {
if (stream == stdout)
stream = state.pager.fptr;
} else {
elfedit_pager_cleanup();
}
}
/*
* If this message is coming from within the libtecla command
* completion code, call gl_normal_io() to give the library notice.
* That function sets the tty back to cooked mode and advances
* the cursor to the beginning of the next line so that our output
* will appear properly. When we return to the command completion code,
* tecla will re-enter raw mode and redraw the current command line.
*/
if (state.input.in_tecla)
(void) gl_normal_io(state.input.gl);
if (do_output) {
if (need_prefix)
(void) fprintf(stream, MSG_ORIG(MSG_STR_ELFEDIT));
(void) vfprintf(stream, format, args);
(void) fflush(stream);
}
va_end(args);
/*
* If this is an error, then we do not return to the caller.
* The action taken depends on whether the outer loop has registered
* a jump buffer for us or not.
*/
if (disp != DISP_RET) {
if (state.msg_jbuf.active && (disp == DISP_JMP)) {
/* Free the user command list */
free_user_cmds();
/* Clean up to reflect effect of non-local goto */
state.input.in_tecla = FALSE;
/* Jump to the outer loop to resume */
siglongjmp(state.msg_jbuf.env, 1);
} else {
elfedit_exit(1);
}
}
}
/*
* Wrapper on elfedit_msg() that issues an error that results from
* a call to libelf.
*
* entry:
* file - Name of ELF object
* libelf_rtn_name - Name of routine that was called
*
* exit:
* An error has been issued that shows the routine called
* and the libelf error string for it from elf_errmsg().
* This routine does not return to the caller.
*/
void
elfedit_elferr(const char *file, const char *libelf_rtn_name)
{
const char *errstr = elf_errmsg(elf_errno());
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_LIBELF), file,
libelf_rtn_name, errstr ? errstr : MSG_INTL(MSG_FMT_UNKNOWN));
}
/*
* Start an output pager process for elfedit_printf()/elfedit_write() to use.
*
* note:
* If this elfedit session is not interactive, then no pager is
* started. Paging is only intended for interactive use. The caller
* is not supposed to worry about this point, but simply to use
* this function to flag situations in which paging might be needed.
*/
void
elfedit_pager_init(void)
{
const char *errstr;
const char *cmd;
int err;
/*
* If there is no pager process running, start one.
* Only do this for interactive sessions --- elfedit_pager()
* won't use a pager in batch mode.
*/
if (state.msg_jbuf.active && state.input.full_tty &&
(state.pager.fptr == NULL)) {
/*
* If the user has the PAGER environment variable set,
* then we will use that program. Otherwise we default
* to /bin/more.
*/
cmd = getenv(MSG_ORIG(MSG_STR_PAGER));
if ((cmd == NULL) || (*cmd == '\0'))
cmd = MSG_ORIG(MSG_STR_BINMORE);
/*
* The popen() manpage says that on failure, it "may set errno",
* which is somewhat ambiguous. We explicitly zero it here, and
* assume that any change is due to popen() failing.
*/
errno = 0;
state.pager.fptr = popen(cmd, MSG_ORIG(MSG_STR_W));
if (state.pager.fptr == NULL) {
err = errno;
errstr = (err == 0) ? MSG_INTL(MSG_ERR_UNKNOWNSYSERR) :
strerror(err);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTEXEC),
MSG_ORIG(MSG_STR_ELFEDIT), cmd, errstr);
}
}
}
/*
* If there is a pager process present, close it out.
*
* note:
* This function is called from within elfedit_msg(), and as
* such, must not use elfedit_msg() to report errors. Furthermore,
* any such errors are not a sufficient reason to terminate the process
* or to longjmp(). This is a rare case where errors are written
* directly to stderr.
*/
static void
elfedit_pager_cleanup(void)
{
if (state.pager.fptr != NULL) {
if (pclose(state.pager.fptr) == -1)
(void) fprintf(stderr, MSG_INTL(MSG_ERR_PAGERFINI));
state.pager.fptr = NULL;
}
}
/*
* Print general formtted text for the user, using printf()-style
* formatting. Uses the pager process if one has been started, or
* stdout otherwise.
*/
void
elfedit_printf(const char *format, ...)
{
va_list args;
int err;
FILE *fptr;
int pager;
int broken_pipe = 0;
/*
* If there is a pager process, then use it. Otherwise write
* directly to stdout.
*/
pager = (state.pager.fptr != NULL);
fptr = pager ? state.pager.fptr : stdout;
va_start(args, format);
errno = 0;
err = vfprintf(fptr, format, args);
/* Did we fail because a child pager process has exited? */
broken_pipe = pager && (err < 0) && (errno == EPIPE);
va_end(args);
/*
* On error, we simply issue the error without cleaning up
* the pager process. The message code handles that as a standard
* part of error processing.
*
* We handle failure due to an exited pager process differently
* than a normal error, because it is usually due to the user
* intentionally telling it to.
*/
if (err < 0) {
if (broken_pipe)
elfedit_msg(ELFEDIT_MSG_QUIET, MSG_ORIG(MSG_STR_NULL));
else
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_PRINTF));
}
}
/*
* Some our modules use liblddb routines to format ELF output.
* In order to ensure that such output is sent to the pager pipe
* when there is one, and stdout otherwise, we redefine the dbg_print()
* function here.
*
* This item should be defined NODIRECT.
*/
/* PRINTFLIKE2 */
void
dbg_print(Lm_list *lml, const char *format, ...)
{
va_list ap;
int err;
FILE *fptr;
int pager;
int broken_pipe = 0;
#if defined(lint)
/*
* The lml argument is only meaningful for diagnostics sent to ld.so.1.
* Supress the lint error by making a dummy assignment.
*/
lml = 0;
#endif
/*
* If there is a pager process, then use it. Otherwise write
* directly to stdout.
*/
pager = (state.pager.fptr != NULL);
fptr = pager ? state.pager.fptr : stdout;
va_start(ap, format);
errno = 0;
err = vfprintf(fptr, format, ap);
if (err >= 0)
err = fprintf(fptr, MSG_ORIG(MSG_STR_NL));
/* Did we fail because a child pager process has exited? */
broken_pipe = (err < 0) && pager && (errno == EPIPE);
va_end(ap);
/*
* On error, we simply issue the error without cleaning up
* the pager process. The message code handles that as a standard
* part of error processing.
*
* We handle failure due to an exited pager process differently
* than a normal error, because it is usually due to the user
* intentionally telling it to.
*/
if (err < 0) {
if (broken_pipe)
elfedit_msg(ELFEDIT_MSG_QUIET, MSG_ORIG(MSG_STR_NULL));
else
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_PRINTF));
}
}
/*
* Write raw bytes of text in a manner similar to fwrite().
* Uses the pager process if one has been started, or
* stdout otherwise.
*/
void
elfedit_write(const void *ptr, size_t size)
{
FILE *fptr;
int err;
/*
* If there is a pager process, then use it. Otherwise write
* directly to stdout.
*/
fptr = (state.pager.fptr == NULL) ? stdout : state.pager.fptr;
if (fwrite(ptr, 1, size, fptr) != size) {
err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_FWRITE),
strerror(err));
}
}
/*
* Wrappers on malloc() and realloc() that check the result for success
* and issue an error if not. The caller can use the result of these
* functions without checking for a NULL pointer, as we do not return to
* the caller in the failure case.
*/
void *
elfedit_malloc(const char *item_name, size_t size)
{
void *m;
m = malloc(size);
if (m == NULL) {
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_MALLOC),
item_name, strerror(err));
}
return (m);
}
void *
elfedit_realloc(const char *item_name, void *ptr, size_t size)
{
void *m;
m = realloc(ptr, size);
if (m == NULL) {
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_MALLOC),
item_name, strerror(err));
}
return (m);
}
/*
* Ensure that the given buffer has room for n bytes of data.
*/
static void
strbuf_ensure_size(STRBUF *str, size_t size)
{
#define INITIAL_STR_ALLOC 128
size_t n;
n = (str->n == 0) ? INITIAL_STR_ALLOC : str->n;
while (size > n) /* Double buffer until string fits */
n *= 2;
if (n != str->n) { /* Alloc new string buffer if needed */
str->buf = elfedit_realloc(MSG_INTL(MSG_ALLOC_UCMDSTR),
str->buf, n);
str->n = n;
}
#undef INITIAL_STR_ALLOC
}
/*
* Extract the argument/option information for the next item referenced
* by optarg, and advance the pointer to the next item.
*
* entry:
* optarg - Address of pointer to argument or option array
* item - Struct to be filled in.
*
* exit:
* The item block has been filled in with the information for
* the next item in the optarg array. *optarg has been advanced
* to the next item.
*/
void
elfedit_next_optarg(elfedit_cmd_optarg_t **optarg, elfedit_optarg_item_t *item)
{
/*
* Array of inheritable options/arguments. Indexed by one less
* than the corresponding ELFEDIT_STDOA_ value.
*/
static const elfedit_optarg_item_t stdoa[] = {
/* ELFEDIT_STDOA_O */
{ MSG_ORIG(MSG_STR_MINUS_O), MSG_ORIG(MSG_STR_OUTSTYLE),
/* MSG_INTL(MSG_STDOA_OPTDESC_O) */
(elfedit_i18nhdl_t)MSG_STDOA_OPTDESC_O,
ELFEDIT_CMDOA_F_VALUE },
/* ELFEDIT_STDOA_AND */
{ MSG_ORIG(MSG_STR_MINUS_AND), NULL,
/* MSG_INTL(MSG_STDOA_OPTDESC_AND) */
(elfedit_i18nhdl_t)MSG_STDOA_OPTDESC_AND, 0 },
/* ELFEDIT_STDOA_CMP */
{ MSG_ORIG(MSG_STR_MINUS_CMP), NULL,
/* MSG_INTL(MSG_STDOA_OPTDESC_CMP) */
(elfedit_i18nhdl_t)MSG_STDOA_OPTDESC_CMP, 0 },
/* ELFEDIT_STDOA_OR */
{ MSG_ORIG(MSG_STR_MINUS_OR), NULL,
/* MSG_INTL(MSG_STDOA_OPTDESC_OR) */
(elfedit_i18nhdl_t)MSG_STDOA_OPTDESC_OR, 0 },
};
elfedit_cmd_optarg_t *oa;
/* Grab first item, advance the callers pointer over it */
oa = (*optarg)++;
if (oa->oa_flags & ELFEDIT_CMDOA_F_INHERIT) {
/* Values are pre-chewed in the stdoa array above */
*item = stdoa[((uintptr_t)oa->oa_name) - 1];
/*
* Set the inherited flag so that elfedit_optarg_helpstr()
* can tell who is responsible for translating the help string.
*/
item->oai_flags |= ELFEDIT_CMDOA_F_INHERIT;
} else { /* Non-inherited item */
item->oai_name = oa->oa_name;
if ((oa->oa_flags & ELFEDIT_CMDOA_F_VALUE) != 0) {
item->oai_vname = oa[1].oa_name;
/* Advance users pointer past value element */
(*optarg)++;
} else {
item->oai_vname = NULL;
}
item->oai_help = oa->oa_help;
item->oai_flags = oa->oa_flags;
}
/*
* The module determines the idmask and excmask fields whether
* or not inheritance is in play.
*/
item->oai_idmask = oa->oa_idmask;
item->oai_excmask = oa->oa_excmask;
}
/*
* Return the help string for an option/argument item, as returned
* by elfedit_next_optarg(). This routine handles the details of
* knowing whether the string is provided by elfedit itself (inherited),
* or needs to be translated by the module.
*/
const char *
elfedit_optarg_helpstr(elfeditGC_module_t *mod, elfedit_optarg_item_t *item)
{
/*
* The help string from an inherited item comes right out
* of the main elfedit string table.
*/
if (item->oai_flags & ELFEDIT_CMDOA_F_INHERIT)
return (MSG_INTL((Msg) item->oai_help));
/*
* If the string is defined by the module, then we need to
* have the module translate it for us.
*/
return ((* mod->mod_i18nhdl_to_str)(item->oai_help));
}
/*
* Used by usage_optarg() to insert a character into the output buffer,
* advancing the buffer pointer and current column, and reducing the
* amount of remaining space.
*/
static void
usage_optarg_insert_ch(int ch, char **cur, size_t *n, size_t *cur_col)
{
*(*cur)++ = ch;
**cur = '\0';
(*n)--;
(*cur_col)++;
}
/*
* Used by usage_optarg() to insert a string into the output
* buffer, advancing the buffer pointer and current column, and reducing
* the amount of remaining space.
*/
static void
usage_optarg_insert_str(char **cur, size_t *n, size_t *cur_col,
const char *format, ...)
{
size_t len;
va_list args;
va_start(args, format);
len = vsnprintf(*cur, *n, format, args);
va_end(args);
*cur += len;
*n -= len;
*cur_col += len;
}
/*
* Used by usage_optarg() to insert an optarg item string into the output
* buffer, advancing the buffer pointer and current column, and reducing
* the amount of remaining space.
*/
static void
usage_optarg_insert_item(elfedit_optarg_item_t *item, char **cur,
size_t *n, size_t *cur_col)
{
size_t len;
if (item->oai_flags & ELFEDIT_CMDOA_F_VALUE) {
len = snprintf(*cur, *n, MSG_ORIG(MSG_STR_HLPOPTARG2),
item->oai_name, item->oai_vname);
} else {
len = snprintf(*cur, *n, MSG_ORIG(MSG_STR_HLPOPTARG),
item->oai_name);
}
*cur += len;
*n -= len;
*cur_col += len;
}
/*
* Write the options/arguments to the usage string.
*
* entry:
* main_buf_n - Size of main buffer from which buf and buf_n are
* allocated.
* buf - Address of pointer to where next item is to be placed.
* buf_n - Address of count of remaining bytes in buffer
* buf_cur_col - Address of current output column for current line
* of generated string.
* optarg - Options list
* isopt - True if these are options, false for arguments.
* wrap_str - String to indent wrapped lines. If NULL, lines
* are not wrapped
*/
static void
usage_optarg(size_t main_buf_n, char **buf, size_t *buf_n, size_t *buf_cur_col,
elfedit_cmd_optarg_t *optarg, int isopt, const char *wrap_str)
{
/*
* An option can be combined into a simple format if it lacks
* these flags and is only one character in length.
*/
static const elfedit_cmd_oa_flag_t exflags =
(ELFEDIT_CMDOA_F_VALUE | ELFEDIT_CMDOA_F_MULT);
/*
* A static buffer, which is grown as needed to accomodate
* the maximum usage string seen.
*/
static STRBUF simple_str;
char *cur = *buf;
size_t n = *buf_n;
size_t cur_col = *buf_cur_col;
int len;
int use_simple = 0;
elfedit_optarg_item_t item;
elfedit_cmd_oa_mask_t optmask = 0;
int use_bkt;
/*
* If processing options, pull the 1-character ones that don't have
* an associated value and don't have any mutual exclusion issues into
* a single combination string to go at the beginning of the usage.
*/
if (isopt) {
elfedit_cmd_optarg_t *tmp_optarg = optarg;
char *s;
/*
* The simple string is guaranteed to fit in the same
* amount of space reserved for the main buffer.
*/
strbuf_ensure_size(&simple_str, main_buf_n);
s = simple_str.buf;
*s++ = ' ';
*s++ = '[';
*s++ = '-';
while (tmp_optarg->oa_name != NULL) {
elfedit_next_optarg(&tmp_optarg, &item);
if (((item.oai_flags & exflags) == 0) &&
(item.oai_name[2] == '\0') &&
(item.oai_excmask == 0)) {
optmask |= item.oai_idmask;
*s++ = item.oai_name[1];
}
}
/*
* If we found more than one, then finish the string and
* add it. Don't do this for a single option, because
* it looks better in that case if the option shows up
* in alphabetical order rather than being hoisted.
*/
use_simple = (s > (simple_str.buf + 4));
if (use_simple) {
*s++ = ']';
*s++ = '\0';
usage_optarg_insert_str(&cur, &n, &cur_col,
MSG_ORIG(MSG_STR_HLPOPTARG), simple_str.buf);
} else {
/* Not using it, so reset the cumulative options mask */
optmask = 0;
}
}
while (optarg->oa_name != NULL) {
elfedit_next_optarg(&optarg, &item);
if (isopt) {
/*
* If this is an option that was pulled into the
* combination string above, then skip over it.
*/
if (use_simple && ((item.oai_flags & exflags) == 0) &&
(item.oai_name[2] == '\0') &&
(item.oai_excmask == 0))
continue;
/*
* If this is a mutual exclusion option that was
* picked up out of order by a previous iteration
* of this loop, then skip over it.
*/
if ((optmask & item.oai_idmask) != 0)
continue;
/* Add this item to the accumulating options mask */
optmask |= item.oai_idmask;
}
/* Wrap line, or insert blank separator */
if ((wrap_str != NULL) && (cur_col > USAGE_WRAP_COL)) {
len = snprintf(cur, n, MSG_ORIG(MSG_FMT_WRAPUSAGE),
wrap_str);
cur += len;
n -= len;
cur_col = len - 1; /* Don't count the newline */
} else {
usage_optarg_insert_ch(' ', &cur, &n, &cur_col);
}
use_bkt = (item.oai_flags & ELFEDIT_CMDOA_F_OPT) || isopt;
if (use_bkt)
usage_optarg_insert_ch('[', &cur, &n, &cur_col);
/* Add the item to the buffer */
usage_optarg_insert_item(&item, &cur, &n, &cur_col);
/*
* If this item has a non-zero mutual exclusion mask,
* then look for the other items and display them all
* together with alternation (|). Note that plain arguments
* cannot have a non-0 exclusion mask, so this is
* effectively options-only (isopt != 0).
*/
if (item.oai_excmask != 0) {
elfedit_cmd_optarg_t *tmp_optarg = optarg;
elfedit_optarg_item_t tmp_item;
/*
* When showing alternation, elipses for multiple
* copies need to appear inside the [] brackets.
*/
if (item.oai_flags & ELFEDIT_CMDOA_F_MULT)
usage_optarg_insert_str(&cur, &n, &cur_col,
MSG_ORIG(MSG_STR_ELIPSES));
while (tmp_optarg->oa_name != NULL) {
elfedit_next_optarg(&tmp_optarg, &tmp_item);
if ((item.oai_excmask & tmp_item.oai_idmask) ==
0)
continue;
usage_optarg_insert_str(&cur, &n, &cur_col,
MSG_ORIG(MSG_STR_SP_BAR_SP));
usage_optarg_insert_item(&tmp_item,
&cur, &n, &cur_col);
/*
* Add it to the mask of seen options.
* This will keep us from showing it twice.
*/
optmask |= tmp_item.oai_idmask;
}
}
if (use_bkt)
usage_optarg_insert_ch(']', &cur, &n, &cur_col);
/*
* If alternation was not shown above (non-zero exclusion mask)
* then the elipses for multiple copies are shown outside
* any [] brackets.
*/
if ((item.oai_excmask == 0) &&
(item.oai_flags & ELFEDIT_CMDOA_F_MULT))
usage_optarg_insert_str(&cur, &n, &cur_col,
MSG_ORIG(MSG_STR_ELIPSES));
}
*buf = cur;
*buf_n = n;
*buf_cur_col = cur_col;
}
/*
* Format the usage string for a command into a static buffer and
* return the pointer to the user. The resultant string is valid
* until the next call to this routine, and which point it
* will be overwritten or the memory is freed.
*
* entry:
* mod, cmd - Module and command definitions for command to be described
* wrap_str - NULL, or string to be used to indent when
* lines are wrapped. If NULL, no wrapping is done, and
* all output is on a single line.
* cur_col - Starting column at which the string will be displayed.
* Ignored if wrap_str is NULL.
*/
const char *
elfedit_format_command_usage(elfeditGC_module_t *mod, elfeditGC_cmd_t *cmd,
const char *wrap_str, size_t cur_col)
{
/*
* A static buffer, which is grown as needed to accomodate
* the maximum usage string seen.
*/
static STRBUF str;
elfedit_cmd_optarg_t *optarg;
size_t len, n, elipses_len;
char *cur;
elfedit_optarg_item_t item;
/*
* Estimate a worst case size for the usage string:
* - module name
* - lengths of the strings
* - every option or argument is enclosed in brackets
* - space in between each item, with an alternation (" | ")
* - elipses will be displayed with each option and argument
*/
n = strlen(mod->mod_name) + strlen(cmd->cmd_name[0]) + 6;
elipses_len = strlen(MSG_ORIG(MSG_STR_ELIPSES));
if ((optarg = cmd->cmd_opt) != NULL)
while (optarg->oa_name != NULL) {
elfedit_next_optarg(&optarg, &item);
n += strlen(item.oai_name) + 5 + elipses_len;
}
if ((optarg = cmd->cmd_args) != NULL)
while (optarg->oa_name != NULL) {
elfedit_next_optarg(&optarg, &item);
n += strlen(item.oai_name) + 5 + elipses_len;
}
n++; /* Null termination */
/*
* If wrapping lines, we insert a newline and then wrap_str
* every USAGE_WRAP_COL characters.
*/
if (wrap_str != NULL)
n += ((n + USAGE_WRAP_COL) / USAGE_WRAP_COL) *
(strlen(wrap_str) + 1);
strbuf_ensure_size(&str, n);
/* Command name */
cur = str.buf;
n = str.n;
if (strcmp(mod->mod_name, MSG_ORIG(MSG_MOD_SYS)) == 0)
len = snprintf(cur, n, MSG_ORIG(MSG_FMT_SYSCMD),
cmd->cmd_name[0]);
else
len = snprintf(cur, n, MSG_ORIG(MSG_FMT_MODCMD),
mod->mod_name, cmd->cmd_name[0]);
cur += len;
n -= len;
cur_col += len;
if (cmd->cmd_opt != NULL)
usage_optarg(str.n, &cur, &n, &cur_col, cmd->cmd_opt,
1, wrap_str);
if (cmd->cmd_args != NULL)
usage_optarg(str.n, &cur, &n, &cur_col, cmd->cmd_args,
0, wrap_str);
return (str.buf);
}
/*
* Wrapper on elfedit_msg() that issues an ELFEDIT_MSG_USAGE
* error giving usage information for the command currently
* referenced by state.cur_cmd.
*/
void
elfedit_command_usage(void)
{
elfedit_msg(ELFEDIT_MSG_CMDUSAGE, MSG_INTL(MSG_USAGE_CMD),
elfedit_format_command_usage(state.cur_cmd->ucmd_mod,
state.cur_cmd->ucmd_cmd, NULL, 0));
}
/*
* This function allows the loadable modules to get the command line
* flags.
*/
elfedit_flag_t
elfedit_flags(void)
{
return (state.flags);
}
/*
* This function is used to register a per-command invocation output style
* that will momentarily override the global output style for the duration
* of the current command. This function must only be called by an
* active command.
*
* entry:
* str - One of the valid strings for the output style
*/
void
elfedit_set_cmd_outstyle(const char *str)
{
if ((state.cur_cmd != NULL) && (str != NULL)) {
if (elfedit_atooutstyle(str, &state.cur_cmd->ucmd_ostyle) == 0)
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_BADOSTYLE), str);
state.cur_cmd->ucmd_ostyle_set = 1;
}
}
/*
* This function allows the loadable modules to get the output style.
*/
elfedit_outstyle_t
elfedit_outstyle(void)
{
/*
* If there is an active per-command output style,
* return it.
*/
if ((state.cur_cmd != NULL) && (state.cur_cmd->ucmd_ostyle_set))
return (state.cur_cmd->ucmd_ostyle);
return (state.outstyle);
}
/*
* Return the command descriptor of the currently executing command.
* For use only by the modules or code called by the modules.
*/
elfeditGC_cmd_t *
elfedit_curcmd(void)
{
return (state.cur_cmd->ucmd_cmd);
}
/*
* Build a dynamically allocated elfedit_obj_state_t struct that
* contains a cache of the ELF file contents. This pre-chewed form
* is fed to each command, reducing the amount of ELF boilerplate
* code each command needs to contain.
*
* entry:
* file - Name of file to process
*
* exit:
* Fills state.elf with the necessary information for the open file.
*
* note: The resulting elfedit_obj_state_t is allocated from a single
* piece of memory, such that a single call to free() suffices
* to release it as well as any memory it references.
*/
static void
init_obj_state(const char *file)
{
int fd;
Elf *elf;
int open_flag;
/*
* In readonly mode, we open the file readonly so that it is
* impossible to modify the file by accident. This also allows
* us to access readonly files, perhaps in a case where we don't
* intend to change it.
*
* We always use ELF_C_RDWR with elf_begin(), even in a readonly
* session. This allows us to modify the in-memory image, which
* can be useful when examining a file, even though we don't intend
* to modify the on-disk data. The file is not writable in
* this case, and we don't call elf_update(), so it is safe to do so.
*/
open_flag = ((state.flags & ELFEDIT_F_READONLY) ? O_RDONLY : O_RDWR);
if ((fd = open(file, open_flag)) == -1) {
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTOPNFILE),
file, strerror(err));
}
(void) elf_version(EV_CURRENT);
elf = elf_begin(fd, ELF_C_RDWR, NULL);
if (elf == NULL) {
(void) close(fd);
elfedit_elferr(file, MSG_ORIG(MSG_ELF_BEGIN));
/*NOTREACHED*/
}
/* We only handle standalone ELF files */
switch (elf_kind(elf)) {
case ELF_K_AR:
(void) close(fd);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOAR), file);
break;
case ELF_K_ELF:
break;
default:
(void) close(fd);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_UNRECELFFILE),
file);
break;
}
/*
* Tell libelf that we take responsibility for object layout.
* Otherwise, it will compute "proper" values for layout and
* alignment fields, and these values can overwrite the values
* set in the elfedit session. We are modifying existing
* objects --- the layout concerns have already been dealt
* with when the object was built.
*/
(void) elf_flagelf(elf, ELF_C_SET, ELF_F_LAYOUT);
/* Fill in state.elf.obj_state */
state.elf.elfclass = gelf_getclass(elf);
switch (state.elf.elfclass) {
case ELFCLASS32:
elfedit32_init_obj_state(file, fd, elf);
break;
case ELFCLASS64:
elfedit64_init_obj_state(file, fd, elf);
break;
default:
(void) close(fd);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_BADELFCLASS),
file);
break;
}
}
#if 0
/*
* Debug routine. Dump the module list to stdout.
*/
static void
dbg_module_list(char *title)
{
MODLIST_T *m;
printf("<MODULE LIST: %s>\n", title);
for (m = state.modlist; m != NULL; m = m->next) {
printf("Module: >%s<\n", m->mod->mod_name);
printf(" hdl: %llx\n", m->dl_hdl);
printf(" path: >%s<\n", m->path ? m->path : "<builtin>");
}
printf("<END OF MODULE LIST>\n");
}
#endif
/*
* Search the module list for the named module.
*
* entry:
* name - Name of module to find
* insdef - Address of variable to receive address of predecessor
* node to the desired one.
*
* exit:
* If the module is it is found, this routine returns the pointer to
* its MODLIST_T structure. *insdef references the predecessor node, or
* is NULL if the found item is at the head of the list.
*
* If the module is not found, NULL is returned. *insdef references
* the predecessor node of the position where an entry for this module
* would be placed, or NULL if it would go at the beginning.
*/
static MODLIST_T *
module_loaded(const char *name, MODLIST_T **insdef)
{
MODLIST_T *moddef;
int cmp;
*insdef = NULL;
moddef = state.modlist;
if (moddef != NULL) {
cmp = strcasecmp(name, moddef->ml_mod->mod_name);
if (cmp == 0) { /* Desired module is first in list */
return (moddef);
} else if (cmp > 0) { /* cmp > 0: Insert in middle/end */
*insdef = moddef;
moddef = moddef->ml_next;
cmp = -1;
while (moddef && (cmp < 0)) {
cmp = strcasecmp(moddef->ml_mod->mod_name,
name);
if (cmp == 0)
return (moddef);
if (cmp < 0) {
*insdef = moddef;
moddef = (*insdef)->ml_next;
}
}
}
}
return (NULL);
}
/*
* Determine if a file is a sharable object based on its file path.
* If path ends in a .so, followed optionally by a period and 1 or more
* digits, we say that it is and return a pointer to the first character
* of the suffix. Otherwise NULL is returned.
*/
static const char *
path_is_so(const char *path)
{
int dotso_len;
const char *tail;
size_t len;
len = strlen(path);
if (len == 0)
return (NULL);
tail = path + len;
if (isdigit(*(tail - 1))) {
while ((tail > path) && isdigit(*(tail - 1)))
tail--;
if ((tail <= path) || (*tail != '.'))
return (NULL);
}
dotso_len = strlen(MSG_ORIG(MSG_STR_DOTSO));
if ((tail - path) < dotso_len)
return (NULL);
tail -= dotso_len;
if (strncmp(tail, MSG_ORIG(MSG_STR_DOTSO), dotso_len) == 0)
return (tail);
return (NULL);
}
/*
* Locate the start of the unsuffixed file name within path. Returns pointer
* to first character of that name in path.
*
* entry:
* path - Path to be examined.
* tail - NULL, or pointer to position at tail of path from which
* the search for '/' characters should start. If NULL,
* strlen() is used to locate the end of the string.
* buf - NULL, or buffer to receive a copy of the characters that
* lie between the start of the filename and tail.
* bufsize - sizeof(buf)
*
* exit:
* The pointer to the first character of the unsuffixed file name
* within path is returned. If buf is non-NULL, the characters
* lying between that point and tail (or the end of path if tail
* is NULL) are copied into buf.
*/
static const char *
elfedit_basename(const char *path, const char *tail, char *buf, size_t bufsiz)
{
const char *s;
if (tail == NULL)
tail = path + strlen(path);
s = tail;
while ((s > path) && (*(s - 1) != '/'))
s--;
if (buf != NULL)
elfedit_strnbcpy(buf, s, tail - s, bufsiz);
return (s);
}
/*
* Issue an error on behalf of load_module(), taking care to release
* resources that routine may have aquired:
*
* entry:
* moddef - NULL, or a module definition to be released via free()
* dl_hdl - NULL, or a handle to a sharable object to release via
* dlclose().
* dl_path - If dl_hdl is non-NULL, the path to the sharable object
* file that was loaded.
* format - A format string to pass to elfedit_msg(), containing
* no more than (3) %s format codes, and no other format codes.
* [s1-s4] - Strings to pass to elfedit_msg() to satisfy the four
* allowed %s codes in format. Should be set to NULL if the
* format string does not need them.
*
* note:
* This routine makes a copy of the s1-s4 strings before freeing any
* memory or unmapping the sharable library. It is therefore safe to
* use strings from moddef, or from the sharable library (which will
* be unmapped) to satisfy the other arguments s1-s4.
*/
static void
load_module_err(MODLIST_T *moddef, void *dl_hdl, const char *dl_path,
const char *format, const char *s1, const char *s2, const char *s3,
const char *s4)
{
#define SCRBUFSIZE (PATH_MAX + 256) /* A path, plus some extra */
char s1_buf[SCRBUFSIZE];
char s2_buf[SCRBUFSIZE];
char s3_buf[SCRBUFSIZE];
char s4_buf[SCRBUFSIZE];
/*
* The caller may provide strings for s1-s3 that are from
* moddef. If we free moddef, the printf() will die on access
* to free memory. We could push back on the user and force
* each call to carefully make copies of such data. However, this
* is an easy case to miss. Furthermore, this is an error case,
* and machine efficiency is not the main issue. We therefore make
* copies of the s1-s3 strings here into auto variables, and then
* use those copies. The user is freed from worrying about it.
*
* We use oversized stack based buffers instead of malloc() to
* reduce the number of ways that things can go wrong while
* reporting the error.
*/
if (s1 != NULL)
(void) strlcpy(s1_buf, s1, sizeof (s1_buf));
if (s2 != NULL)
(void) strlcpy(s2_buf, s2, sizeof (s2_buf));
if (s3 != NULL)
(void) strlcpy(s3_buf, s3, sizeof (s3_buf));
if (s4 != NULL)
(void) strlcpy(s4_buf, s4, sizeof (s4_buf));
if (moddef != NULL)
free(moddef);
if ((dl_hdl != NULL) && (dlclose(dl_hdl) != 0))
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTDLCLOSE),
dl_path, dlerror());
elfedit_msg(ELFEDIT_MSG_ERR, format, s1_buf, s2_buf, s3_buf, s4_buf);
#undef SCRBUFSIZE
}
/*
* Load a module sharable object for load_module().
*
* entry:
* path - Path of file to open
* moddef - If this function issues a non-returning error, it will
* first return the memory referenced by moddef. This argument
* is not used otherwise.
* must_exist - If True, we consider it to be an error if the file given
* by path does not exist. If False, no error is issued
* and a NULL value is quietly returned.
*
* exit:
* Returns a handle to the loaded object on success, or NULL if no
* file was loaded.
*/
static void *
load_module_dlopen(const char *path, MODLIST_T *moddef, int must_exist)
{
int fd;
void *hdl;
/*
* If the file is not required to exist, and it doesn't, then
* we want to quietly return without an error.
*/
if (!must_exist) {
fd = open(path, O_RDONLY);
if (fd >= 0) {
(void) close(fd);
} else if (errno == ENOENT) {
return (NULL);
}
}
if ((hdl = dlopen(path, RTLD_LAZY|RTLD_FIRST)) == NULL)
load_module_err(moddef, NULL, NULL,
MSG_INTL(MSG_ERR_CNTDLOPEN), path, dlerror(), NULL, NULL);
return (hdl);
}
/*
* Sanity check option arguments to prevent common errors. The rest of
* elfedit assumes these tests have been done, and does not check
* again.
*/
static void
validate_optarg(elfedit_cmd_optarg_t *optarg, int isopt, MODLIST_T *moddef,
const char *mod_name, const char *cmd_name,
void *dl_hdl, const char *dl_path)
{
#define FAIL(_msg) errmsg = _msg; goto fail
Msg errmsg;
elfedit_cmd_oa_mask_t optmask = 0;
for (; optarg->oa_name != NULL; optarg++) {
/*
* If ELFEDIT_CMDOA_F_INHERIT is set:
* - oa_name must be a value in the range of
* known ELFEDIT_STDOA_ values.
* - oa_help must be NULL
* - ELFEDIT_CMDOA_F_INHERIT must be the only flag set
*/
if (optarg->oa_flags & ELFEDIT_CMDOA_F_INHERIT) {
if ((((uintptr_t)optarg->oa_name) >
ELFEDIT_NUM_STDOA) ||
(optarg->oa_help != 0) ||
(optarg->oa_flags != ELFEDIT_CMDOA_F_INHERIT))
/*
* Can't use FAIL --- oa_name is not a valid
* string, and load_module_err() looks at args.
*/
load_module_err(moddef, dl_hdl, dl_path,
MSG_INTL(MSG_ERR_BADSTDOA), dl_path,
mod_name, cmd_name, NULL);
continue;
}
if (isopt) {
/*
* Option name must start with a '-', and must
* have at one following character.
*/
if (optarg->oa_name[0] != '-') {
/* MSG_INTL(MSG_ERR_OPT_MODPRE) */
FAIL(MSG_ERR_OPT_MODPRE);
}
if (optarg->oa_name[1] == '\0') {
/* MSG_INTL(MSG_ERR_OPT_MODLEN) */
FAIL(MSG_ERR_OPT_MODLEN);
}
/*
* oa_idmask must be 0, or it must have a single
* bit set (a power of 2).oa_excmask must be 0
* if oa_idmask is 0
*/
if (optarg->oa_idmask == 0) {
if (optarg->oa_excmask != 0) {
/* MSG_INTL(MSG_ERR_OPT_EXCMASKN0) */
FAIL(MSG_ERR_OPT_EXCMASKN0);
}
} else {
if (elfedit_bits_set(optarg->oa_idmask,
sizeof (optarg->oa_idmask)) != 1) {
/* MSG_INTL(MSG_ERR_OPT_IDMASKPOW2) */
FAIL(MSG_ERR_OPT_IDMASKPOW2);
}
/* Non-zero idmask must be unique */
if ((optarg->oa_idmask & optmask) != 0) {
/* MSG_INTL(MSG_ERR_OPT_IDMASKUNIQ) */
FAIL(MSG_ERR_OPT_IDMASKUNIQ);
}
/* Add this one to the overall mask */
optmask |= optarg->oa_idmask;
}
} else {
/*
* Argument name cannot start with a'-', and must
* not be a null string.
*/
if (optarg->oa_name[0] == '-') {
/* MSG_INTL(MSG_ERR_ARG_MODPRE) */
FAIL(MSG_ERR_ARG_MODPRE);
}
if (optarg->oa_name[1] == '\0') {
/* MSG_INTL(MSG_ERR_ARG_MODLEN) */
FAIL(MSG_ERR_ARG_MODLEN);
}
/* oa_idmask and oa_excmask must both be 0 */
if ((optarg->oa_idmask != 0) ||
(optarg->oa_excmask != 0)) {
/* MSG_INTL(MSG_ERR_ARG_MASKNOT0) */
FAIL(MSG_ERR_ARG_MASKNOT0);
}
}
/*
* If it takes a value, make sure that we are
* processing options, because CMDOA_F_VALUE is not
* allowed for plain arguments. Then check the following
* item in the list:
* - There must be a following item.
* - oa_name must be non-NULL. This is the only field
* that is used by elfedit.
* - oa_help, oa_flags, oa_idmask, and oa_excmask
* must be 0.
*/
if (optarg->oa_flags & ELFEDIT_CMDOA_F_VALUE) {
elfedit_cmd_optarg_t *oa1 = optarg + 1;
if (!isopt) {
/* MSG_INTL(MSG_ERR_ARG_CMDOA_VAL) */
FAIL(MSG_ERR_ARG_CMDOA_VAL);
}
if ((optarg + 1)->oa_name == NULL) {
/* MSG_INTL(MSG_ERR_BADMODOPTVAL) */
FAIL(MSG_ERR_BADMODOPTVAL);
}
if (oa1->oa_name == NULL) {
/* MSG_INTL(MSG_ERR_CMDOA_VALNAM) */
FAIL(MSG_ERR_CMDOA_VALNAM);
}
if ((oa1->oa_help != NULL) || (oa1->oa_flags != 0) ||
(oa1->oa_idmask != 0) || (oa1->oa_excmask != 0)) {
/* MSG_INTL(MSG_ERR_CMDOA_VALNOT0) */
FAIL(MSG_ERR_CMDOA_VALNOT0);
}
optarg++;
}
}
return;
fail:
load_module_err(moddef, dl_hdl, dl_path, MSG_INTL(errmsg),
dl_path, mod_name, cmd_name, optarg->oa_name);
}
/*
* Look up the specified module, loading the module if necessary,
* and return its definition, or NULL on failure.
*
* entry:
* name - Name of module to load. If name contains a '/' character or has
* a ".so" suffix, then it is taken to be an absolute file path,
* and is used directly as is. If name does not contain a '/'
* character, then we look for it against the locations in
* the module path, addint the '.so' suffix, and taking the first
* one we find.
* must_exist - If True, we consider it to be an error if we are unable
* to locate a file to load and the module does not already exist.
* If False, NULL is returned quietly in this case.
* allow_abs - True if absolute paths are allowed. False to disallow
* them.
*
* note:
* If the path is absolute, then we load the file and take the module
* name from the data returned by its elfedit_init() function. If a
* module of that name is already loaded, it is unloaded and replaced
* with the new one.
*
* If the path is non absolute, then we check to see if the module has
* already been loaded, and if so, we return that module definition.
* In this case, nothing new is loaded. If the module has not been loaded,
* we search the path for it and load it. If the module name provided
* by the elfedit_init() function does not match the name of the file,
* an error results.
*/
elfeditGC_module_t *
elfedit_load_module(const char *name, int must_exist, int allow_abs)
{
elfedit_init_func_t *init_func;
elfeditGC_module_t *mod;
MODLIST_T *moddef, *insdef;
const char *path;
char path_buf[PATH_MAX + 1];
void *hdl;
size_t i;
int is_abs_path;
elfeditGC_cmd_t *cmd;
/*
* If the name includes a .so suffix, or has any '/' characters,
* then it is an absolute path that we use as is to load the named
* file. Otherwise, we iterate over the path, adding the .so suffix
* and load the first file that matches.
*/
is_abs_path = (path_is_so(name) != NULL) ||
(name != elfedit_basename(name, NULL, NULL, 0));
if (is_abs_path && !allow_abs)
load_module_err(NULL, NULL, NULL,
MSG_INTL(MSG_ERR_UNRECMOD), name, NULL, NULL, NULL);
/*
* If this is a non-absolute path, search for the module already
* having been loaded, and return it if so.
*/
if (!is_abs_path) {
moddef = module_loaded(name, &insdef);
if (moddef != NULL)
return (moddef->ml_mod);
/*
* As a result of module_loaded(), insdef now contains the
* immediate predecessor node for the new one, or NULL if
* it goes at the front. In the absolute-path case, we take
* care of this below, after the sharable object is loaded.
*/
}
/*
* malloc() a module definition block before trying to dlopen().
* Doing things in the other order can cause the dlopen()'d object
* to leak: If elfedit_malloc() fails, it can cause a jump to the
* outer command loop without returning to the caller. Hence,
* there will be no opportunity to clean up. Allocaing the module
* first allows us to free it if necessary.
*/
moddef = elfedit_malloc(MSG_INTL(MSG_ALLOC_MODDEF),
sizeof (*moddef) + PATH_MAX + 1);
moddef->ml_path = ((char *)moddef) + sizeof (*moddef);
if (is_abs_path) {
path = name;
hdl = load_module_dlopen(name, moddef, must_exist);
} else {
hdl = NULL;
path = path_buf;
for (i = 0; i < state.modpath.n; i++) {
if (snprintf(path_buf, sizeof (path_buf),
MSG_ORIG(MSG_FMT_BLDSOPATH), state.modpath.seg[i],
name) > sizeof (path_buf))
load_module_err(moddef, NULL, NULL,
MSG_INTL(MSG_ERR_PATHTOOLONG),
state.modpath.seg[i], name, NULL, NULL);
hdl = load_module_dlopen(path, moddef, 0);
}
if (must_exist && (hdl == NULL))
load_module_err(moddef, NULL, NULL,
MSG_INTL(MSG_ERR_UNRECMOD), name, NULL, NULL, NULL);
}
if (hdl == NULL) {
free(moddef);
return (NULL);
}
if (state.elf.elfclass == ELFCLASS32) {
init_func = (elfedit_init_func_t *)
dlsym(hdl, MSG_ORIG(MSG_STR_ELFEDITINIT32));
} else {
init_func = (elfedit_init_func_t *)
dlsym(hdl, MSG_ORIG(MSG_STR_ELFEDITINIT64));
}
if (init_func == NULL)
load_module_err(moddef, hdl, path,
MSG_INTL(MSG_ERR_SONOTMOD), path, NULL, NULL, NULL);
/*
* Note that the init function will be passing us an
* elfedit[32|64]_module_t pointer, which we cast to the
* generic module pointer type in order to be able to manage
* either type with one set of code.
*/
if (!(mod = (elfeditGC_module_t *)(* init_func)(ELFEDIT_VER_CURRENT)))
load_module_err(moddef, hdl, path,
MSG_INTL(MSG_ERR_BADMODLOAD), path, NULL, NULL, NULL);
/*
* Enforce some rules, to help module developers:
* - The primary name of a command must not be
* the empty string ("").
* - Options must start with a '-' followed by at least
* one character.
* - Arguments and options must be well formed.
*/
for (cmd = mod->mod_cmds; cmd->cmd_func != NULL; cmd++) {
if (**cmd->cmd_name == '\0')
load_module_err(moddef, hdl, path,
MSG_INTL(MSG_ERR_NULLPRICMDNAM), mod->mod_name,
NULL, NULL, NULL);
if (cmd->cmd_args != NULL)
validate_optarg(cmd->cmd_args, 0, moddef, mod->mod_name,
cmd->cmd_name[0], hdl, path);
if (cmd->cmd_opt != NULL)
validate_optarg(cmd->cmd_opt, 1, moddef, mod->mod_name,
cmd->cmd_name[0], hdl, path);
}
/*
* Check the name the module provides. How we handle this depends
* on whether the path is absolute or the result of a path search.
*/
if (is_abs_path) {
MODLIST_T *old_moddef = module_loaded(mod->mod_name, &insdef);
if (old_moddef != NULL) { /* Replace existing */
free(moddef); /* Rare case: Don't need it */
/*
* Be sure we don't unload builtin modules!
* These have a NULL dl_hdl field.
*/
if (old_moddef->ml_dl_hdl == NULL)
load_module_err(NULL, hdl, path,
MSG_INTL(MSG_ERR_CNTULSMOD),
old_moddef->ml_mod->mod_name, NULL,
NULL, NULL);
/* Unload existing */
if (dlclose(old_moddef->ml_dl_hdl) != 0)
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_CNTDLCLOSE),
old_moddef->ml_path, dlerror());
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_MODUNLOAD),
old_moddef->ml_mod->mod_name, old_moddef->ml_path);
old_moddef->ml_mod = mod;
old_moddef->ml_dl_hdl = hdl;
(void) strlcpy((char *)old_moddef->ml_path, path,
PATH_MAX + 1);
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_MODLOAD),
old_moddef->ml_mod->mod_name, path);
return (old_moddef->ml_mod);
}
/*
* insdef now contains the insertion point for the absolute
* path case.
*/
} else {
/* If the names don't match, then error */
if (strcasecmp(name, mod->mod_name) != 0)
load_module_err(moddef, hdl, path,
MSG_INTL(MSG_ERR_BADMODNAME),
mod->mod_name, name, path, NULL);
}
/*
* Link module into the module list. If insdef is NULL,
* it goes at the head. If insdef is non-NULL, it goes immediately
* after
*/
if (insdef == NULL) {
moddef->ml_next = state.modlist;
state.modlist = moddef;
} else {
moddef->ml_next = insdef->ml_next;
insdef->ml_next = moddef;
}
moddef->ml_mod = mod;
moddef->ml_dl_hdl = hdl;
(void) strlcpy((char *)moddef->ml_path, path, PATH_MAX + 1);
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_MODLOAD),
moddef->ml_mod->mod_name, path);
return (moddef->ml_mod);
}
/*
* Unload the specified module
*/
void
elfedit_unload_module(const char *name)
{
MODLIST_T *moddef, *insdef;
moddef = module_loaded(name, &insdef);
if (moddef == NULL)
return;
/* Built in modules cannot be unloaded. They have a NULL dl_hdl field */
if (moddef->ml_dl_hdl == NULL)
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTULSMOD),
moddef->ml_mod->mod_name);
/*
* When we unload it, the name string goes with it. So
* announce it while we still can without having to make a copy.
*/
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_MODUNLOAD),
moddef->ml_mod->mod_name, moddef->ml_path);
/*
* Close it before going further. On failure, we'll jump, and the
* record will remain in the module list. On success,
* we'll retain control, and can safely remove it.
*/
if (dlclose(moddef->ml_dl_hdl) != 0)
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTDLCLOSE),
moddef->ml_path, dlerror());
/* Unlink the record from the module list */
if (insdef == NULL)
state.modlist = moddef->ml_next;
else
insdef->ml_next = moddef->ml_next;
/* Release the memory */
free(moddef);
}
/*
* Load all sharable objects found in the specified directory.
*
* entry:
* dirpath - Path of directory to process.
* must_exist - If True, it is an error if diropen() fails to open
* the given directory. Of False, we quietly ignore it and return.
* abs_path - If True, files are loaded using their literal paths.
* If False, their module name is extracted from the dirpath
* and a path based search is used to locate it.
*/
void
elfedit_load_moddir(const char *dirpath, int must_exist, int abs_path)
{
char path[PATH_MAX + 1];
DIR *dir;
struct dirent *dp;
const char *tail;
dir = opendir(dirpath);
if (dir == NULL) {
int err = errno;
if (!must_exist && (err == ENOENT))
return;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTOPNDIR),
dirpath, strerror(err));
/*NOTREACHED*/
}
while (dp = readdir(dir)) {
if ((tail = path_is_so(dp->d_name)) != NULL) {
if (abs_path) {
(void) snprintf(path, sizeof (path),
MSG_ORIG(MSG_FMT_BLDPATH), dirpath,
dp->d_name);
} else {
(void) elfedit_basename(dp->d_name, tail,
path, sizeof (path));
}
(void) elfedit_load_module(path, must_exist, 1);
}
}
(void) closedir(dir);
}
/*
* Follow the module load path, and load the first module found for each
* given name.
*/
void
elfedit_load_modpath(void)
{
size_t i;
for (i = 0; i < state.modpath.n; i++)
elfedit_load_moddir(state.modpath.seg[i], 0, 0);
}
/*
* Given a module definition, look for the specified command.
* Returns the command if found, and NULL otherwise.
*/
static elfeditGC_cmd_t *
find_cmd(elfeditGC_module_t *mod, const char *name)
{
elfeditGC_cmd_t *cmd;
const char **cmd_name;
for (cmd = mod->mod_cmds; cmd->cmd_func != NULL; cmd++)
for (cmd_name = cmd->cmd_name; *cmd_name; cmd_name++)
if (strcasecmp(name, *cmd_name) == 0) {
if (cmd_name != cmd->cmd_name)
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_CMDALIAS),
mod->mod_name, *cmd_name,
mod->mod_name, *cmd->cmd_name);
return (cmd);
}
return (NULL);
}
/*
* Given a command name, return its command definition.
*
* entry:
* name - Command to be looked up
* must_exist - If True, we consider it to be an error if the command
* does not exist. If False, NULL is returned quietly in
* this case.
* mod_ret - NULL, or address of a variable to receive the
* module definition block of the module containing
* the command.
*
* exit:
* On success, returns a pointer to the command definition, and
* if mod_ret is non-NULL, *mod_ret receives a pointer to the
* module definition. On failure, must_exist determines the
* action taken: If must_exist is True, an error is issued and
* control does not return to the caller. If must_exist is False,
* NULL is quietly returned.
*
* note:
* A ':' in name is used to delimit the module and command names.
* If it is omitted, or if it is the first non-whitespace character
* in the name, then the built in sys: module is implied.
*/
elfeditGC_cmd_t *
elfedit_find_command(const char *name, int must_exist,
elfeditGC_module_t **mod_ret)
{
elfeditGC_module_t *mod;
const char *mod_str;
const char *cmd_str;
char mod_buf[ELFEDIT_MAXMODNAM + 1];
size_t n;
elfeditGC_cmd_t *cmd;
cmd_str = strstr(name, MSG_ORIG(MSG_STR_COLON));
if (cmd_str == NULL) { /* No module name -> sys: */
mod_str = MSG_ORIG(MSG_MOD_SYS);
cmd_str = name;
} else if (cmd_str == name) { /* Empty module name -> sys: */
mod_str = MSG_ORIG(MSG_MOD_SYS);
cmd_str++; /* Skip the colon */
} else { /* Have both module and command */
n = cmd_str - name;
if (n >= sizeof (mod_buf)) {
if (must_exist)
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_MODNAMTOOLONG), name);
return (NULL);
}
(void) strlcpy(mod_buf, name, n + 1);
mod_str = mod_buf;
cmd_str++;
}
/* Lookup/load module. Won't return on error */
mod = elfedit_load_module(mod_str, must_exist, 0);
if (mod == NULL)
return (NULL);
/* Locate the command */
cmd = find_cmd(mod, cmd_str);
if (cmd == NULL) {
if (must_exist) {
/*
* Catch empty command in order to provide
* a better error message.
*/
if (*cmd_str == '\0') {
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_MODNOCMD), mod_str);
} else {
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_UNRECCMD),
mod_str, cmd_str);
}
}
} else {
if (mod_ret != NULL)
*mod_ret = mod;
}
return (cmd);
}
/*
* Release all user command blocks found on state.ucmd
*/
static void
free_user_cmds(void)
{
USER_CMD_T *next;
while (state.ucmd.list) {
next = state.ucmd.list->ucmd_next;
free(state.ucmd.list);
state.ucmd.list = next;
}
state.ucmd.tail = NULL;
state.ucmd.n = 0;
state.cur_cmd = NULL;
}
/*
* Process all user command blocks found on state.ucmd, and then
* remove them from the list.
*/
static void
dispatch_user_cmds()
{
USER_CMD_T *ucmd;
elfedit_cmdret_t cmd_ret;
ucmd = state.ucmd.list;
if (ucmd) {
/* Do them, in order */
for (; ucmd; ucmd = ucmd->ucmd_next) {
state.cur_cmd = ucmd;
if (!state.msg_jbuf.active)
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_EXECCMD),
ucmd->ucmd_orig_str);
/*
* The cmd_func field is the generic definition.
* We need to cast it to the type that matches
* the proper ELFCLASS before calling it.
*/
if (state.elf.elfclass == ELFCLASS32) {
elfedit32_cmd_func_t *cmd_func =
(elfedit32_cmd_func_t *)
ucmd->ucmd_cmd->cmd_func;
cmd_ret = (* cmd_func)(state.elf.obj_state.s32,
ucmd->ucmd_argc, ucmd->ucmd_argv);
} else {
elfedit64_cmd_func_t *cmd_func =
(elfedit64_cmd_func_t *)
ucmd->ucmd_cmd->cmd_func;
cmd_ret = (* cmd_func)(state.elf.obj_state.s64,
ucmd->ucmd_argc, ucmd->ucmd_argv);
}
state.cur_cmd = NULL;
/* If a pager was started, wrap it up */
elfedit_pager_cleanup();
switch (cmd_ret) {
case ELFEDIT_CMDRET_MOD:
/*
* Command modified the output ELF image,
* mark the file as needing a flush to disk.
*/
state.file.dirty = 1;
break;
case ELFEDIT_CMDRET_FLUSH:
/*
* Command flushed the output file,
* clear the dirty bit.
*/
state.file.dirty = 0;
}
}
free_user_cmds();
}
}
/*
* Prepare a GETTOK_STATE struct for gettok().
*
* entry:
* gettok_state - gettok state block to use
* str - Writable buffer to tokenize. Note that gettok()
* is allowed to change the contents of this buffer.
* inc_null_final - If the line ends in whitespace instead of
* immediately hitting a NULL, and inc_null_final is TRUE,
* then a null final token is generated. Otherwise trailing
* whitespace is ignored.
*/
static void
gettok_init(GETTOK_STATE *gettok_state, char *buf, int inc_null_final)
{
gettok_state->gtok_buf = gettok_state->gtok_cur_buf = buf;
gettok_state->gtok_inc_null_final = inc_null_final;
gettok_state->gtok_null_seen = 0;
}
/*
* Locate the next token from the buffer.
*
* entry:
* gettok_state - State of gettok() operation. Initialized
* by gettok_init(), and passed to gettok().
*
* exit:
* If a token is found, gettok_state->gtok_last_token is filled in
* with the details and True (1) is returned. If no token is found,
* False (1) is returned, and the contents of
* gettok_state->gtok_last_token are undefined.
*
* note:
* - The token returned references the memory in gettok_state->gtok_buf.
* The caller should not modify the buffer until all such
* pointers have been discarded.
* - This routine will modify the contents of gettok_state->gtok_buf
* as necessary to remove quotes and eliminate escape
* (\)characters.
*/
static int
gettok(GETTOK_STATE *gettok_state)
{
char *str = gettok_state->gtok_cur_buf;
char *look;
int quote_ch = '\0';
/* Skip leading whitespace */
while (isspace(*str))
str++;
if (*str == '\0') {
/*
* If user requested it, and there was whitespace at the
* end, then generate one last null token.
*/
if (gettok_state->gtok_inc_null_final &&
!gettok_state->gtok_null_seen) {
gettok_state->gtok_inc_null_final = 0;
gettok_state->gtok_null_seen = 1;
gettok_state->gtok_last_token.tok_str = str;
gettok_state->gtok_last_token.tok_len = 0;
gettok_state->gtok_last_token.tok_line_off =
str - gettok_state->gtok_buf;
return (1);
}
gettok_state->gtok_null_seen = 1;
return (0);
}
/*
* Read token: The standard delimiter is whitespace, but
* we honor either single or double quotes. Also, we honor
* backslash escapes.
*/
gettok_state->gtok_last_token.tok_str = look = str;
gettok_state->gtok_last_token.tok_line_off =
look - gettok_state->gtok_buf;
for (; *look; look++) {
if (*look == quote_ch) { /* Terminates active quote */
quote_ch = '\0';
continue;
}
if (quote_ch == '\0') { /* No quote currently active */
if ((*look == '\'') || (*look == '"')) {
quote_ch = *look; /* New active quote */
continue;
}
if (isspace(*look))
break;
}
if (*look == '\\') {
look++;
if (*look == '\0') /* Esc applied to NULL term? */
break;
}
if (look != str)
*str = *look;
str++;
}
gettok_state->gtok_last_token.tok_len = str -
gettok_state->gtok_last_token.tok_str;
gettok_state->gtok_null_seen = *look == '\0';
if (!gettok_state->gtok_null_seen)
look++;
*str = '\0';
gettok_state->gtok_cur_buf = look;
#if 0
printf("GETTOK >%s< len(%d) offset(%d)\n",
gettok_state->gtok_last_token.tok_str,
gettok_state->gtok_last_token.tok_len,
gettok_state->gtok_last_token.tok_line_off);
#endif
return (1);
}
/*
* Tokenize the user command string, and return a pointer to the
* TOK_STATE buffer maintained by this function. That buffer contains
* the tokenized strings.
*
* entry:
* user_cmd_str - String to tokenize
* len - # of characters in user_cmd_str to examine. If
* (len < 0), then the complete string is processed
* stopping with the NULL termination. Otherwise,
* processing stops after len characters, and any
* remaining characters are ignored.
* inc_null_final - If True, and if user_cmd_str has whitespace
* at the end following the last non-null token, then
* a final null token will be included. If False, null
* tokens are ignored.
*
* note:
* This routine returns pointers to internally allocated memory.
* The caller must not alter anything contained in the TOK_STATE
* buffer returned. Furthermore, the the contents of TOK_STATE
* are only valid until the next call to tokenize_user_cmd().
*/
static TOK_STATE *
tokenize_user_cmd(const char *user_cmd_str, size_t len, int inc_null_final)
{
#define INITIAL_TOK_ALLOC 5
/*
* As we parse the user command, we need temporary space to
* hold the tokens. We do this by dynamically allocating a string
* buffer and a token array, and doubling them as necessary. This
* is a single threaded application, so static variables suffice.
*/
static STRBUF str;
static TOK_STATE tokst;
GETTOK_STATE gettok_state;
size_t n;
/*
* Make a copy we can modify. If (len == 0), take the entire
* string. Otherwise limit it to the specified length.
*/
tokst.tokst_cmd_len = strlen(user_cmd_str);
if ((len > 0) && (len < tokst.tokst_cmd_len))
tokst.tokst_cmd_len = len;
tokst.tokst_cmd_len++; /* Room for NULL termination */
strbuf_ensure_size(&str, tokst.tokst_cmd_len);
(void) strlcpy(str.buf, user_cmd_str, tokst.tokst_cmd_len);
/* Trim off any newline character that might be present */
if ((tokst.tokst_cmd_len > 1) &&
(str.buf[tokst.tokst_cmd_len - 2] == '\n')) {
tokst.tokst_cmd_len--;
str.buf[tokst.tokst_cmd_len - 1] = '\0';
}
/* Tokenize the user command string into tok struct */
gettok_init(&gettok_state, str.buf, inc_null_final);
tokst.tokst_str_size = 0; /* Space needed for token strings */
for (tokst.tokst_cnt = 0; gettok(&gettok_state) != 0;
tokst.tokst_cnt++) {
/* If we need more room, expand the token buffer */
if (tokst.tokst_cnt >= tokst.tokst_bufsize) {
n = (tokst.tokst_bufsize == 0) ?
INITIAL_TOK_ALLOC : (tokst.tokst_bufsize * 2);
tokst.tokst_buf = elfedit_realloc(
MSG_INTL(MSG_ALLOC_TOKBUF), tokst.tokst_buf,
n * sizeof (*tokst.tokst_buf));
tokst.tokst_bufsize = n;
}
tokst.tokst_str_size +=
gettok_state.gtok_last_token.tok_len + 1;
tokst.tokst_buf[tokst.tokst_cnt] = gettok_state.gtok_last_token;
}
/* fold the command token to lowercase */
if (tokst.tokst_cnt > 0) {
char *s;
for (s = tokst.tokst_buf[0].tok_str; *s; s++)
if (isupper(*s))
*s = tolower(*s);
}
return (&tokst);
#undef INITIAL_TOK_ALLOC
}
/*
* Parse the user command string, and put an entry for it at the end
* of state.ucmd.
*/
static void
parse_user_cmd(const char *user_cmd_str)
{
TOK_STATE *tokst;
char *s;
size_t n;
size_t len;
USER_CMD_T *ucmd;
elfeditGC_module_t *mod;
elfeditGC_cmd_t *cmd;
/*
* Break it into tokens. If there are none, then it is
* an empty command and is ignored.
*/
tokst = tokenize_user_cmd(user_cmd_str, -1, 0);
if (tokst->tokst_cnt == 0)
return;
/* Find the command. Won't return on error */
cmd = elfedit_find_command(tokst->tokst_buf[0].tok_str, 1, &mod);
/*
* If there is no ELF file being edited, then only commands
* from the sys: module are allowed.
*/
if ((state.file.present == 0) &&
(strcmp(mod->mod_name, MSG_ORIG(MSG_MOD_SYS)) != 0))
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOFILSYSONLY),
mod->mod_name, cmd->cmd_name[0]);
/* Allocate, fill in, and insert a USER_CMD_T block */
n = S_DROUND(sizeof (USER_CMD_T));
ucmd = elfedit_malloc(MSG_INTL(MSG_ALLOC_UCMD),
n + (sizeof (char *) * (tokst->tokst_cnt - 1)) +
tokst->tokst_cmd_len + tokst->tokst_str_size);
ucmd->ucmd_next = NULL;
ucmd->ucmd_argc = tokst->tokst_cnt - 1;
/*LINTED E_BAD_PTR_CAST_ALIGN*/
ucmd->ucmd_argv = (const char **)(n + (char *)ucmd);
ucmd->ucmd_orig_str = (char *)(ucmd->ucmd_argv + ucmd->ucmd_argc);
(void) strncpy(ucmd->ucmd_orig_str, user_cmd_str, tokst->tokst_cmd_len);
ucmd->ucmd_mod = mod;
ucmd->ucmd_cmd = cmd;
ucmd->ucmd_ostyle_set = 0;
s = ucmd->ucmd_orig_str + tokst->tokst_cmd_len;
for (n = 1; n < tokst->tokst_cnt; n++) {
len = tokst->tokst_buf[n].tok_len + 1;
ucmd->ucmd_argv[n - 1] = s;
(void) strncpy(s, tokst->tokst_buf[n].tok_str, len);
s += len;
}
if (state.ucmd.list == NULL) {
state.ucmd.list = state.ucmd.tail = ucmd;
} else {
state.ucmd.tail->ucmd_next = ucmd;
state.ucmd.tail = ucmd;
}
state.ucmd.n++;
}
/*
* Copy infile to a new file with the name given by outfile.
*/
static void
create_outfile(const char *infile, const char *outfile)
{
pid_t pid;
int statloc;
struct stat statbuf;
pid = fork();
switch (pid) {
case -1: /* Unable to create process */
{
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTFORK),
strerror(err));
}
/*NOTREACHED*/
return;
case 0:
(void) execl(MSG_ORIG(MSG_STR_BINCP),
MSG_ORIG(MSG_STR_BINCP), infile, outfile, NULL);
/*
* exec() only returns on error. This is the child process,
* so we want to stay away from the usual error mechanism
* and handle things directly.
*/
{
int err = errno;
(void) fprintf(stderr, MSG_INTL(MSG_ERR_CNTEXEC),
MSG_ORIG(MSG_STR_ELFEDIT),
MSG_ORIG(MSG_STR_BINCP), strerror(err));
}
exit(1);
/*NOTREACHED*/
}
/* This is the parent: Wait for the child to terminate */
if (waitpid(pid, &statloc, 0) != pid) {
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTWAIT),
strerror(err));
}
/*
* If the child failed, then terminate the process. There is no
* need for an error message, because the child will have taken
* care of that.
*/
if (!WIFEXITED(statloc) || (WEXITSTATUS(statloc) != 0))
exit(1);
/* Make sure the copy allows user write access */
if (stat(outfile, &statbuf) == -1) {
int err = errno;
(void) unlink(outfile);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTSTAT),
outfile, strerror(err));
}
if ((statbuf.st_mode & S_IWUSR) == 0) {
/* Only keep permission bits, and add user write */
statbuf.st_mode |= S_IWUSR;
statbuf.st_mode &= 07777; /* Only keep the permission bits */
if (chmod(outfile, statbuf.st_mode) == -1) {
int err = errno;
(void) unlink(outfile);
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTCHMOD),
outfile, strerror(err));
}
}
}
/*
* Given a module path string, determine how long the resulting path will
* be when all % tokens have been expanded.
*
* entry:
* path - Path for which expanded length is desired
* origin_root - Root of $ORIGIN tree containing running elfedit program
*
* exit:
* Returns the value strlen() will give for the expanded path.
*/
static size_t
modpath_strlen(const char *path, const char *origin_root)
{
size_t len = 0;
const char *s;
s = path;
len = 0;
for (s = path; *s != '\0'; s++) {
if (*s == '%') {
s++;
switch (*s) {
case 'i': /* ISA of running elfedit */
len += strlen(isa_i_str);
break;
case 'I': /* "" for 32-bit, same as %i for 64 */
len += strlen(isa_I_str);
break;
case 'o': /* Insert default path */
len +=
modpath_strlen(MSG_ORIG(MSG_STR_MODPATH),
origin_root);
break;
case 'r': /* root of tree with running elfedit */
len += strlen(origin_root);
break;
case '%': /* %% is reduced to just '%' */
len++;
break;
default: /* All other % codes are reserved */
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_BADPATHCODE), *s);
/*NOTREACHED*/
break;
}
} else { /* Non-% character passes straight through */
len++;
}
}
return (len);
}
/*
* Given a module path string, and a buffer large enough to hold the results,
* fill the buffer with the expanded path.
*
* entry:
* path - Path for which expanded length is desired
* origin_root - Root of tree containing running elfedit program
* buf - Buffer to receive the result. buf must as large or larger
* than the value given by modpath_strlen().
*
* exit:
* Returns pointer to location following the last character
* written to buf. A NULL byte is written to that address.
*/
static char *
modpath_expand(const char *path, const char *origin_root, char *buf)
{
size_t len;
const char *cp_str;
for (; *path != '\0'; path++) {
if (*path == '%') {
path++;
cp_str = NULL;
switch (*path) {
case 'i': /* ISA of running elfedit */
cp_str = isa_i_str;
break;
case 'I': /* "" for 32-bit, same as %i for 64 */
cp_str = isa_I_str;
break;
case 'o': /* Insert default path */
buf = modpath_expand(MSG_ORIG(MSG_STR_MODPATH),
origin_root, buf);
break;
case 'r':
cp_str = origin_root;
break;
case '%': /* %% is reduced to just '%' */
*buf++ = *path;
break;
default: /* All other % codes are reserved */
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_BADPATHCODE), *path);
/*NOTREACHED*/
break;
}
if ((cp_str != NULL) && ((len = strlen(cp_str)) > 0)) {
bcopy(cp_str, buf, len);
buf += len;
}
} else { /* Non-% character passes straight through */
*buf++ = *path;
}
}
*buf = '\0';
return (buf);
}
/*
* Establish the module search path: state.modpath
*
* The path used comes from the following sources, taking the first
* one that has a value, and ignoring any others:
*
* - ELFEDIT_PATH environment variable
* - -L command line argument
* - Default value
*
* entry:
* path - NULL, or the value of the -L command line argument
*
* exit:
* state.modpath has been filled in
*/
static void
establish_modpath(const char *cmdline_path)
{
char origin_root[PATH_MAX + 1]; /* Where elfedit binary is */
const char *path; /* Initial path */
char *expath; /* Expanded path */
size_t len;
char *src, *dst;
path = getenv(MSG_ORIG(MSG_STR_ENVVAR));
if (path == NULL)
path = cmdline_path;
if (path == NULL)
path = MSG_ORIG(MSG_STR_MODPATH);
/*
* Root of tree containing running for running program. 32-bit elfedit
* is installed in /usr/bin, and 64-bit elfedit is one level lower
* in an ISA-specific subdirectory. So, we find the root by
* getting the $ORGIN of the current running program, and trimming
* off the last 2 (32-bit) or 3 (64-bit) directories.
*
* On a standard system, this will simply yield '/'. However,
* doing it this way allows us to run elfedit from a proto area,
* and pick up modules from the same proto area instead of those
* installed on the system.
*/
if (dlinfo(RTLD_SELF, RTLD_DI_ORIGIN, &origin_root) == -1)
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_CNTGETORIGIN));
len = (sizeof (char *) == 8) ? 3 : 2;
src = origin_root + strlen(origin_root);
while ((src > origin_root) && (len > 0)) {
if (*(src - 1) == '/')
len--;
src--;
}
*src = '\0';
/*
* Calculate space needed to hold expanded path. Note that
* this assumes that MSG_STR_MODPATH will never contain a '%o'
* code, and so, the expansion is not recursive. The codes allowed
* are:
* %i - ISA of running elfedit (sparc, sparcv9, etc)
* %I - 64-bit ISA: Same as %i for 64-bit versions of elfedit,
* but yields empty string for 32-bit ISAs.
* %o - The original (default) path.
* %r - Root of tree holding elfedit program.
* %% - A single %
*
* A % followed by anything else is an error. This allows us to
* add new codes in the future without backward compatability issues.
*/
len = modpath_strlen(path, origin_root);
expath = elfedit_malloc(MSG_INTL(MSG_ALLOC_EXPATH), len + 1);
(void) modpath_expand(path, origin_root, expath);
/*
* Count path segments, eliminate extra '/', and replace ':'
* with NULL.
*/
state.modpath.n = 1;
for (src = dst = expath; *src; src++) {
if (*src == '/') {
switch (*(src + 1)) {
case '/':
case ':':
case '\0':
continue;
}
}
if (*src == ':') {
state.modpath.n++;
*dst = '\0';
} else if (src != dst) {
*dst = *src;
}
dst++;
}
if (src != dst)
*dst = '\0';
state.modpath.seg = elfedit_malloc(MSG_INTL(MSG_ALLOC_PATHARR),
sizeof (state.modpath.seg[0]) * state.modpath.n);
src = expath;
for (len = 0; len < state.modpath.n; len++) {
if (*src == '\0') {
state.modpath.seg[len] = MSG_ORIG(MSG_STR_DOT);
src++;
} else {
state.modpath.seg[len] = src;
src += strlen(src) + 1;
}
}
}
/*
* When interactive (reading commands from a tty), we catch
* SIGINT in order to restart the outer command loop.
*/
/*ARGSUSED*/
static void
sigint_handler(int sig, siginfo_t *sip, void *ucp)
{
/* Jump to the outer loop to resume */
if (state.msg_jbuf.active) {
state.msg_jbuf.active = 0;
siglongjmp(state.msg_jbuf.env, 1);
}
}
static void
usage(int full)
{
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_BRIEF));
if (full) {
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL1));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL2));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL3));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL4));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL5));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL6));
elfedit_msg(ELFEDIT_MSG_USAGE, MSG_INTL(MSG_USAGE_DETAIL_LAST));
}
elfedit_exit(2);
}
/*
* In order to complete commands, we need to know about them,
* which means that we need to force all the modules to be
* loaded. This is a relatively expensive operation, so we use
* this function, which avoids doing it more than once in a session.
*/
static void
elfedit_cpl_load_modules(void)
{
static int loaded;
if (!loaded) {
elfedit_load_modpath();
loaded = 1; /* Don't do it again */
}
}
/*
* Compare the token to the given string, and if they share a common
* initial sequence, add the tail of string to the tecla command completion
* buffer:
*
* entry:
* cpldata - Current completion state
* str - String to match against token
* casefold - True to allow case insensitive completion, False
* if case must match exactly.
*/
void
elfedit_cpl_match(void *cpldata, const char *str, int casefold)
{
ELFEDIT_CPL_STATE *cstate = (ELFEDIT_CPL_STATE *) cpldata;
const char *cont_suffix;
const char *type_suffix;
/*
* Reasons to return immediately:
* - NULL strings have no completion value
* - The string is shorter than the existing item being completed
*/
if ((str == NULL) || (*str == '\0') ||
((cstate->ecpl_token_len != 0) &&
((strlen(str) < cstate->ecpl_token_len))))
return;
/* If the string does not share the existing prefix, don't use it */
if (casefold) {
if (strncasecmp(cstate->ecpl_token_str, str,
cstate->ecpl_token_len) != 0)
return;
} else {
if (strncmp(cstate->ecpl_token_str, str,
cstate->ecpl_token_len) != 0)
return;
}
if (cstate->ecpl_add_mod_colon) {
cont_suffix = type_suffix = MSG_ORIG(MSG_STR_COLON);
} else {
cont_suffix = MSG_ORIG(MSG_STR_SPACE);
type_suffix = NULL;
}
(void) cpl_add_completion(cstate->ecpl_cpl, cstate->ecpl_line,
cstate->ecpl_word_start, cstate->ecpl_word_end,
str + cstate->ecpl_token_len, type_suffix, cont_suffix);
}
/*
* Compare the token to the names of the commands from the given module,
* and if they share a common initial sequence, add the tail of string
* to the tecla command completion buffer:
*
* entry:
* tok_buf - Token user has entered
* tok_len - strlen(tok_buf)
* mod - Module definition from which commands should be matched
* cpl, line, word_start, word_end, cont_suffix - As documented
* for gl_get_line() and cpl_add_completion.
*/
static void
match_module_cmds(ELFEDIT_CPL_STATE *cstate, elfeditGC_module_t *mod)
{
elfeditGC_cmd_t *cmd;
const char **cmd_name;
for (cmd = mod->mod_cmds; cmd->cmd_func != NULL; cmd++)
for (cmd_name = cmd->cmd_name; *cmd_name; cmd_name++)
elfedit_cpl_match(cstate, *cmd_name, 1);
}
/*
* Compare the token to the known module names, and add those that
* match to the list of alternatives via elfedit_cpl_match().
*
* entry:
* load_all_modules - If True, causes all modules to be loaded
* before processing is done. If False, only the modules
* currently seen will be used.
*/
void
elfedit_cpl_module(void *cpldata, int load_all_modules)
{
ELFEDIT_CPL_STATE *cstate = (ELFEDIT_CPL_STATE *) cpldata;
MODLIST_T *modlist;
if (load_all_modules)
elfedit_cpl_load_modules();
for (modlist = state.modlist; modlist != NULL;
modlist = modlist->ml_next) {
elfedit_cpl_match(cstate, modlist->ml_mod->mod_name, 1);
}
}
/*
* Compare the token to all the known commands, and add those that
* match to the list of alternatives.
*
* note:
* This routine will force modules to be loaded as necessary to
* obtain the names it needs to match.
*/
void
elfedit_cpl_command(void *cpldata)
{
ELFEDIT_CPL_STATE *cstate = (ELFEDIT_CPL_STATE *) cpldata;
ELFEDIT_CPL_STATE colon_state;
const char *colon_pos;
MODLIST_T *modlist;
MODLIST_T *insdef;
char buf[128];
/*
* Is there a colon in the command? If so, locate its offset within
* the raw input line.
*/
for (colon_pos = cstate->ecpl_token_str;
*colon_pos && (*colon_pos != ':'); colon_pos++)
;
/*
* If no colon was seen, then we are completing a module name,
* or one of the commands from 'sys:'
*/
if (*colon_pos == '\0') {
/*
* Setting cstate->add_mod_colon tells elfedit_cpl_match()
* to add an implicit ':' to the names it matches. We use it
* here so the user doesn't have to enter the ':' manually.
* Hiding this in the opaque state instead of making it
* an argument to that function gives us the ability to
* change it later without breaking the published interface.
*/
cstate->ecpl_add_mod_colon = 1;
elfedit_cpl_module(cpldata, 1);
cstate->ecpl_add_mod_colon = 0;
/* Add bare (no sys: prefix) commands from the sys: module */
match_module_cmds(cstate,
elfedit_load_module(MSG_ORIG(MSG_MOD_SYS), 1, 0));
return;
}
/*
* A colon was seen, so we have a module name. Extract the name,
* substituting 'sys' for the case where the given name is empty.
*/
if (colon_pos == 0)
(void) strlcpy(buf, MSG_ORIG(MSG_MOD_SYS), sizeof (buf));
else
elfedit_strnbcpy(buf, cstate->ecpl_token_str,
colon_pos - cstate->ecpl_token_str, sizeof (buf));
/*
* Locate the module. If it isn't already loaded, make an explicit
* attempt to load it and try again. If a module definition is
* obtained, process the commands it supplies.
*/
modlist = module_loaded(buf, &insdef);
if (modlist == NULL) {
(void) elfedit_load_module(buf, 0, 0);
modlist = module_loaded(buf, &insdef);
}
if (modlist != NULL) {
/*
* Make a copy of the cstate, and adjust the line and
* token so that the new one starts just past the colon
* character. We know that the colon exists because
* of the preceeding test that found it. Therefore, we do
* not need to test against running off the end of the
* string here.
*/
colon_state = *cstate;
while (colon_state.ecpl_line[colon_state.ecpl_word_start] !=
':')
colon_state.ecpl_word_start++;
while (*colon_state.ecpl_token_str != ':') {
colon_state.ecpl_token_str++;
colon_state.ecpl_token_len--;
}
/* Skip past the ':' character */
colon_state.ecpl_word_start++;
colon_state.ecpl_token_str++;
colon_state.ecpl_token_len--;
match_module_cmds(&colon_state, modlist->ml_mod);
}
}
/*
* Command completion function for use with libtacla.
*/
/*ARGSUSED1*/
static int
cmd_match_fcn(WordCompletion *cpl, void *data, const char *line, int word_end)
{
const char *argv[ELFEDIT_MAXCPLARGS];
ELFEDIT_CPL_STATE cstate;
TOK_STATE *tokst;
int ndx;
int i;
elfeditGC_module_t *mod;
elfeditGC_cmd_t *cmd;
int num_opt;
int opt_term_seen;
int skip_one;
elfedit_cmd_optarg_t *optarg;
elfedit_optarg_item_t item;
int ostyle_ndx = -1;
/*
* For debugging, enable the following block. It tells the tecla
* library that the program using is going to write to stdout.
* It will put the tty back into normal mode, and it will cause
* tecla to redraw the current input line when it gets control back.
*/
#if 0
gl_normal_io(state.input.gl);
#endif
/*
* Tokenize the line up through word_end. The last token in
* the list is the one requiring completion.
*/
tokst = tokenize_user_cmd(line, word_end, 1);
if (tokst->tokst_cnt == 0)
return (0);
/* Set up the cstate block, containing the completion state */
ndx = tokst->tokst_cnt - 1; /* Index of token to complete */
cstate.ecpl_cpl = cpl;
cstate.ecpl_line = line;
cstate.ecpl_word_start = tokst->tokst_buf[ndx].tok_line_off;
cstate.ecpl_word_end = word_end;
cstate.ecpl_add_mod_colon = 0;
cstate.ecpl_token_str = tokst->tokst_buf[ndx].tok_str;
cstate.ecpl_token_len = tokst->tokst_buf[ndx].tok_len;
/*
* If there is only one token, then we are completing the
* command itself.
*/
if (ndx == 0) {
elfedit_cpl_command(&cstate);
return (0);
}
/*
* There is more than one token. Use the first one to
* locate the definition for the command. If we don't have
* a definition for the command, then there's nothing more
* we can do.
*/
cmd = elfedit_find_command(tokst->tokst_buf[0].tok_str, 0, &mod);
if (cmd == NULL)
return (0);
/*
* Since we know the command, give them a quick usage message.
* It may be that they just need a quick reminder about the form
* of the command and the options.
*/
(void) gl_normal_io(state.input.gl);
elfedit_printf(MSG_INTL(MSG_USAGE_CMD),
elfedit_format_command_usage(mod, cmd, NULL, 0));
/*
* We have a generous setting for ELFEDIT_MAXCPLARGS, so there
* should always be plenty of room. If there's not room, we
* can't proceed.
*/
if (ndx >= ELFEDIT_MAXCPLARGS)
return (0);
/*
* Put pointers to the tokens into argv, and determine how
* many of the tokens are optional arguments.
*
* We consider the final optional argument to be the rightmost
* argument that starts with a '-'. If a '--' is seen, then
* we stop there, and any argument that follows is a plain argument
* (even if it starts with '-').
*
* We look for an inherited '-o' option, because we are willing
* to supply command completion for these values.
*/
num_opt = 0;
opt_term_seen = 0;
skip_one = 0;
for (i = 0; i < ndx; i++) {
argv[i] = tokst->tokst_buf[i + 1].tok_str;
if (opt_term_seen || skip_one) {
skip_one = 0;
continue;
}
skip_one = 0;
ostyle_ndx = -1;
if ((strcmp(argv[i], MSG_ORIG(MSG_STR_MINUS_MINUS)) == NULL) ||
(*argv[i] != '-')) {
opt_term_seen = 1;
continue;
}
num_opt = i + 1;
/*
* If it is a recognised ELFEDIT_CMDOA_F_VALUE option,
* then the item following it is the associated value.
* Check for this and skip the value.
*
* At the same time, look for STDOA_OPT_O inherited
* options. We want to identify the index of any such
* item. Although the option is simply "-o", we are willing
* to treat any option that starts with "-o" as a potential
* STDOA_OPT_O. This lets us to command completion for things
* like "-onum", and is otherwise harmless, the only cost
* being a few additional strcmps by the cpl code.
*/
if ((optarg = cmd->cmd_opt) == NULL)
continue;
while (optarg->oa_name != NULL) {
int is_ostyle_optarg =
(optarg->oa_flags & ELFEDIT_CMDOA_F_INHERIT) &&
(optarg->oa_name == ELFEDIT_STDOA_OPT_O);
elfedit_next_optarg(&optarg, &item);
if (item.oai_flags & ELFEDIT_CMDOA_F_VALUE) {
if (is_ostyle_optarg && (strncmp(argv[i],
MSG_ORIG(MSG_STR_MINUS_O), 2) == 0))
ostyle_ndx = i + 1;
if (strcmp(item.oai_name, argv[i]) == 0) {
num_opt = i + 2;
skip_one = 1;
break;
}
/*
* If it didn't match "-o" exactly, but it is
* ostyle_ndx, then it is a potential combined
* STDOA_OPT_O, as discussed above. It counts
* as a single argument.
*/
if (ostyle_ndx == ndx)
break;
}
}
}
#if 0
printf("NDX(%d) NUM_OPT(%d) ostyle_ndx(%d)\n", ndx, num_opt,
ostyle_ndx);
#endif
if (ostyle_ndx != -1) {
/*
* If ostyle_ndx is one less than ndx, and ndx is
* the same as num_opt, then we have a definitive
* STDOA_OPT_O inherited outstyle option. We supply
* the value strings, and are done.
*/
if ((ostyle_ndx == (ndx - 1)) && (ndx == num_opt)) {
elfedit_cpl_atoconst(&cstate, ELFEDIT_CONST_OUTSTYLE);
return (0);
}
/*
* If ostyle is the same as ndx, then we have an option
* staring with "-o" that may end up being a STDOA_OPT_O,
* and we are still inside that token. In this case, we
* supply completion strings that include the leading
* "-o" followed by the values, without a space
* (i.e. "-onum"). We then fall through, allowing any
* other options starting with "-o" to be added
* below. elfedit_cpl_match() will throw out the incorrect
* options, so it is harmless to add these extra items in
* the worst case, and useful otherwise.
*/
if (ostyle_ndx == ndx)
elfedit_cpl_atoconst(&cstate,
ELFEDIT_CONST_OUTSTYLE_MO);
}
/*
* If (ndx <= num_opt), then the token needing completion
* is an option. If the leading '-' is there, then we should fill
* in all of the option alternatives. If anything follows the '-'
* though, we assume that the user has already figured out what
* option to use, and we leave well enough alone.
*
* Note that we are intentionally ignoring a related case
* where supplying option strings would be legal: In the case
* where we are one past the last option (ndx == (num_opt + 1)),
* and the current option is an empty string, the argument can
* be either a plain argument or an option --- the user needs to
* enter the next character before we can tell. It would be
* OK to enter the option strings in this case. However, consider
* what happens when the first plain argument to the command does
* not provide any command completion (e.g. it is a plain integer).
* In this case, tecla will see that all the alternatives start
* with '-', and will insert a '-' into the input. If the user
* intends the next argument to be plain, they will have to delete
* this '-', which is annoying. Worse than that, they may be confused
* by it, and think that the plain argument is not allowed there.
* The best solution is to not supply option strings unless the
* user first enters the '-'.
*/
if ((ndx <= num_opt) && (argv[ndx - 1][0] == '-')) {
if ((optarg = cmd->cmd_opt) != NULL) {
while (optarg->oa_name != NULL) {
elfedit_next_optarg(&optarg, &item);
elfedit_cpl_match(&cstate, item.oai_name, 1);
}
}
return (0);
}
/*
* At this point we know that ndx and num_opt are not equal.
* If num_opt is larger than ndx, then we have an ELFEDIT_CMDOA_F_VALUE
* argument at the end, and the following value has not been entered.
*
* If ndx is greater than num_opt, it means that we are looking
* at a plain argument (or in the case where (ndx == (num_opt + 1)),
* a *potential* plain argument.
*
* If the command has a completion function registered, then we
* hand off the remaining work to it. The cmd_cplfunc field is
* the generic definition. We need to cast it to the type that matches
* the proper ELFCLASS before calling it.
*/
if (state.elf.elfclass == ELFCLASS32) {
elfedit32_cmdcpl_func_t *cmdcpl_func =
(elfedit32_cmdcpl_func_t *)cmd->cmd_cplfunc;
if (cmdcpl_func != NULL)
(* cmdcpl_func)(state.elf.obj_state.s32,
&cstate, ndx, argv, num_opt);
} else {
elfedit64_cmdcpl_func_t *cmdcpl_func =
(elfedit64_cmdcpl_func_t *)cmd->cmd_cplfunc;
if (cmdcpl_func != NULL)
(* cmdcpl_func)(state.elf.obj_state.s64,
&cstate, ndx, argv, num_opt);
}
return (0);
}
/*
* Read a line of input from stdin, and return pointer to it.
*
* This routine uses a private buffer, so the contents of the returned
* string are only good until the next call.
*/
static const char *
read_cmd(void)
{
char *s;
if (state.input.full_tty) {
state.input.in_tecla = TRUE;
s = gl_get_line(state.input.gl,
MSG_ORIG(MSG_STR_PROMPT), NULL, -1);
state.input.in_tecla = FALSE;
/*
* gl_get_line() returns NULL for EOF or for error. EOF is fine,
* but we need to catch and report anything else. Since
* reading from stdin is critical to our operation, an
* error implies that we cannot recover and must exit.
*/
if ((s == NULL) &&
(gl_return_status(state.input.gl) == GLR_ERROR)) {
elfedit_msg(ELFEDIT_MSG_FATAL, MSG_INTL(MSG_ERR_GLREAD),
gl_error_message(state.input.gl, NULL, 0));
}
} else {
/*
* This should be a dynamically sized buffer, but for now,
* I'm going to take a simpler path.
*/
static char cmd_buf[ELFEDIT_MAXCMD + 1];
s = fgets(cmd_buf, sizeof (cmd_buf), stdin);
}
/* Return user string, or 'quit' on EOF */
return (s ? s : MSG_ORIG(MSG_SYS_CMD_QUIT));
}
int
main(int argc, char **argv, char **envp)
{
/*
* Note: This function can use setjmp()/longjmp() which does
* not preserve the values of auto/register variables. Hence,
* variables that need their values preserved across a jump must
* be marked volatile, or must not be auto/register.
*
* Volatile can be messy, because it requires explictly casting
* away the attribute when passing it to functions, or declaring
* those functions with the attribute as well. In a single threaded
* program like this one, an easier approach is to make things
* static. That can be done here, or by putting things in the
* 'state' structure.
*/
int c, i;
int num_batch = 0;
char **batch_list = NULL;
const char *modpath = NULL;
/*
* Always have liblddb display unclipped section names.
* This global is exported by liblddb, and declared in debug.h.
*/
dbg_desc->d_extra |= DBG_E_LONG;
opterr = 0;
while ((c = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != EOF) {
switch (c) {
case 'a':
state.flags |= ELFEDIT_F_AUTOPRINT;
break;
case 'd':
state.flags |= ELFEDIT_F_DEBUG;
break;
case 'e':
/*
* Delay parsing the -e options until after the call to
* conv_check_native() so that we won't bother loading
* modules of the wrong class.
*/
if (batch_list == NULL)
batch_list = elfedit_malloc(
MSG_INTL(MSG_ALLOC_BATCHLST),
sizeof (*batch_list) * (argc - 1));
batch_list[num_batch++] = optarg;
break;
case 'L':
modpath = optarg;
break;
case 'o':
if (elfedit_atooutstyle(optarg, &state.outstyle) == 0)
usage(1);
break;
case 'r':
state.flags |= ELFEDIT_F_READONLY;
break;
case '?':
usage(1);
}
}
/*
* We allow 0, 1, or 2 files:
*
* The no-file case is an extremely limited mode, in which the
* only commands allowed to execute come from the sys: module.
* This mode exists primarily to allow easy access to the help
* facility.
*
* To get full access to elfedit's capablities, there must
* be an input file. If this is not a readonly
* session, then an optional second output file is allowed.
*
* In the case where two files are given and the session is
* readonly, use a full usage message, because the simple
* one isn't enough for the user to understand their error.
* Otherwise, the simple usage message suffices.
*/
argc = argc - optind;
if ((argc == 2) && (state.flags & ELFEDIT_F_READONLY))
usage(1);
if (argc > 2)
usage(0);
state.file.present = (argc != 0);
/*
* If we have a file to edit, and unless told otherwise by the
* caller, we try to run the 64-bit version of this program
* when the system is capable of it. If that fails, then we
* continue on with the currently running version.
*
* To force 32-bit execution on a 64-bit host, set the
* LD_NOEXEC_64 environment variable to a non-empty value.
*
* There is no reason to bother with this if in "no file" mode.
*/
if (state.file.present != 0)
(void) conv_check_native(argv, envp);
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_VERSION),
(sizeof (char *) == 8) ? 64 : 32);
/*
* Put a module definition for the builtin system module on the
* module list. We know it starts out empty, so we do not have
* to go through a more general insertion process than this.
*/
state.modlist = elfedit_sys_init(ELFEDIT_VER_CURRENT);
/* Establish the search path for loadable modules */
establish_modpath(modpath);
/*
* Now that we are running the final version of this program,
* deal with the input/output file(s).
*/
if (state.file.present == 0) {
/*
* This is arbitrary --- we simply need to be able to
* load modules so that we can access their help strings
* and command completion functions. Without a file, we
* will refuse to call commands from any module other
* than sys. Those commands have been written to be aware
* of the case where there is no input file, and are
* therefore safe to run.
*/
state.elf.elfclass = ELFCLASS32;
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_NOFILE));
} else {
state.file.infile = argv[optind];
if (argc == 1) {
state.file.outfile = state.file.infile;
if (state.flags & ELFEDIT_F_READONLY)
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_READONLY));
else
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_INPLACEWARN),
state.file.infile);
} else {
state.file.outfile = argv[optind + 1];
create_outfile(state.file.infile, state.file.outfile);
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_CPFILE),
state.file.infile, state.file.outfile);
/*
* We are editing a copy of the original file that we
* just created. If we should exit before the edits are
* updated, then we want to unlink this copy so that we
* don't leave junk lying around. Once an update
* succeeds however, we'll leave it in place even
* if an error occurs afterwards.
*/
state.file.unlink_on_exit = 1;
optind++; /* Edit copy instead of the original */
}
init_obj_state(state.file.outfile);
}
/*
* Process commands.
*
* If any -e options were used, then do them and
* immediately exit. On error, exit immediately without
* updating the target ELF file. On success, the 'write'
* and 'quit' commands are implicit in this mode.
*
* If no -e options are used, read commands from stdin.
* quit must be explicitly used. Exit is implicit on EOF.
* If stdin is a tty, then errors do not cause the editor
* to terminate. Rather, the error message is printed, and the
* user prompted to continue.
*/
if (batch_list != NULL) { /* -e was used */
/* Compile the commands */
for (i = 0; i < num_batch; i++)
parse_user_cmd(batch_list[i]);
free(batch_list);
/*
* 'write' and 'quit' are implicit in this mode.
* Add them as well.
*/
if ((state.flags & ELFEDIT_F_READONLY) == 0)
parse_user_cmd(MSG_ORIG(MSG_SYS_CMD_WRITE));
parse_user_cmd(MSG_ORIG(MSG_SYS_CMD_QUIT));
/* And run them. This won't return, thanks to the 'quit' */
dispatch_user_cmds();
} else {
state.input.is_tty = isatty(fileno(stdin));
state.input.full_tty = state.input.is_tty &&
isatty(fileno(stdout));
if (state.input.full_tty) {
struct sigaction act;
act.sa_sigaction = sigint_handler;
(void) sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, NULL) == -1) {
int err = errno;
elfedit_msg(ELFEDIT_MSG_ERR,
MSG_INTL(MSG_ERR_SIGACTION), strerror(err));
}
/*
* If pager process exits before we are done
* writing, we can see SIGPIPE. Prevent it
* from killing the process.
*/
(void) sigignore(SIGPIPE);
/* Open tecla handle for command line editing */
state.input.gl = new_GetLine(ELFEDIT_MAXCMD,
ELFEDIT_MAXHIST);
/* Register our command completion function */
(void) gl_customize_completion(state.input.gl,
NULL, cmd_match_fcn);
/*
* Make autoprint the default for interactive
* sessions.
*/
state.flags |= ELFEDIT_F_AUTOPRINT;
}
for (;;) {
/*
* If this is an interactive session, then use
* sigsetjmp()/siglongjmp() to recover from bad
* commands and keep going. A non-0 return from
* sigsetjmp() means that an error just occurred.
* In that case, we simply restart this loop.
*/
if (state.input.is_tty) {
if (sigsetjmp(state.msg_jbuf.env, 1) != 0) {
if (state.input.full_tty)
gl_abandon_line(state.input.gl);
continue;
}
state.msg_jbuf.active = TRUE;
}
/*
* Force all output out before each command.
* This is a no-OP when a tty is in use, but
* in a pipeline, it ensures that the block
* mode buffering doesn't delay output past
* the completion of each command.
*
* If we didn't do this, the output would eventually
* arrive at its destination, but the lag can be
* annoying when you pipe the output into a tool
* that displays the results in real time.
*/
(void) fflush(stdout);
(void) fflush(stderr);
parse_user_cmd(read_cmd());
dispatch_user_cmds();
state.msg_jbuf.active = FALSE;
}
}
/*NOTREACHED*/
return (0);
}