/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2008 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include #include #include /* * Dynamic section */ /* * This module uses shared code for several of the commands. * It is sometimes necessary to know which specific command * is active. */ typedef enum { /* Dump command, used as module default to display dynamic section */ DYN_CMD_T_DUMP = 0, /* dyn:dump */ /* Commands that do not correspond directly to a specific DT tag */ DYN_CMD_T_TAG = 1, /* dyn:tag */ DYN_CMD_T_VALUE = 2, /* dyn:value */ DYN_CMD_T_DELETE = 3, /* dyn:delete */ DYN_CMD_T_MOVE = 4, /* dyn:shift */ /* Commands that embody tag specific knowledge */ DYN_CMD_T_RUNPATH = 5, /* dyn:runpath/rpath */ DYN_CMD_T_POSFLAG1 = 6, /* dyn:posflag1 */ DYN_CMD_T_FLAGS = 7, /* dyn:flags */ DYN_CMD_T_FLAGS1 = 8, /* dyn:flags1 */ DYN_CMD_T_FEATURE1 = 9, /* dyn:feature1 */ DYN_CMD_T_CHECKSUM = 10, /* dyn:checksum */ DYN_CMD_T_SUNW_LDMACH = 11 /* dyn:sunw_ldmach */ } DYN_CMD_T; #ifndef _ELF64 /* * We supply this function for the msg module */ const char * _dyn_msg(Msg mid) { return (gettext(MSG_ORIG(mid))); } #endif /* * This function is supplied to elfedit through our elfedit_module_t * definition. It translates the opaque elfedit_i18nhdl_t handles * in our module interface into the actual strings for elfedit to * use. * * note: * This module uses Msg codes for its i18n handle type. * So the translation is simply to use MSG_INTL() to turn * it into a string and return it. */ static const char * mod_i18nhdl_to_str(elfedit_i18nhdl_t hdl) { Msg msg = (Msg)hdl; return (MSG_INTL(msg)); } /* * The dyn_opt_t enum specifies a bit value for every optional * argument allowed by a command in this module. */ typedef enum { DYN_OPT_F_ADD = 1, /* -add: Add new elt rather than */ /* modifying an existing one */ DYN_OPT_F_AND = 2, /* -and: AND (&) values to dest */ DYN_OPT_F_CMP = 4, /* -cmp: Complement (~) values */ DYN_OPT_F_DYNNDX_ELT = 8, /* -dynndx: 1st plain arg is tag */ /* index, not name */ DYN_OPT_F_DYNNDX_VAL = 16, /* -dynndx ndx: Index is value to */ /* option rather than 1st plain */ /* arg. Used for dyn:posflag1 */ DYN_OPT_F_NEEDED = 32, /* -needed str: Locate DT_POSFLAG_1 */ /* relative to DT_NEEDED element */ DYN_OPT_F_OR = 64, /* -or: OR (|) values to dest */ DYN_OPT_F_STRVAL = 128 /* -s: value is string, not integer */ } dyn_opt_t; /* * A variable of type ARGSTATE is used by each command to maintain * information about the arguments and related things. It is * initialized by process_args(), and used by the other routines. */ typedef struct { elfedit_obj_state_t *obj_state; elfedit_section_t *strsec; /* Dynamic string table ref */ struct { elfedit_section_t *sec; /* Dynamic section reference */ Dyn *data; /* Start dynamic section data */ Word num; /* # dynamic elts */ Word null_ndx; /* Index of first DT_NULL */ Word num_null_ndx; /* # of DT_NULL elements */ } dyn; dyn_opt_t optmask; /* Mask of options used */ int argc; /* # of plain arguments */ const char **argv; /* Plain arguments */ const char *dyn_elt_str; /* Value string for */ /* DYN_OPT_F_DYNNDX_VAL */ /* or DYN_OPT_F_NEEDED */ } ARGSTATE; /* * Set argstate null_ndx field for current dynamic area */ static void set_null_ndx(ARGSTATE *argstate) { Word num, null_ndx; num = argstate->dyn.num; argstate->dyn.num_null_ndx = 0; for (null_ndx = 0; null_ndx < num; null_ndx++) if (argstate->dyn.data[null_ndx].d_tag == DT_NULL) { argstate->dyn.num_null_ndx++; break; } argstate->dyn.null_ndx = null_ndx; /* Count the number of remaining DT_NULL items */ for (; null_ndx < num; null_ndx++) if (argstate->dyn.data[null_ndx].d_tag == DT_NULL) argstate->dyn.num_null_ndx++; } /* * Convert the first available DT_NULL slot in the dynamic section * into something else. * * entry: * argstate - Argument state block * d_tag, d_val - Values to be set in new element * * exit: * If an extra DT_NULL slot is available, a debug message is * issued, the slot is converted to its new use, and the argstate * block state related to DT_NULL slots is updated. * * if no extra DT_NULL slot is present, an error is issued and * this routine does not return to the caller. */ static Word convert_dt_null(ARGSTATE *argstate, Word d_tag, Xword d_val) { Conv_inv_buf_t inv_buf; Word ndx; Dyn *dyn; /* If we lack an extra element, we can't continue */ if (argstate->dyn.num_null_ndx <= 1) elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOEXTRANULL), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name); elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_CONVNULL), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, EC_WORD(argstate->dyn.null_ndx), conv_dyn_tag(d_tag, argstate->obj_state->os_ehdr->e_machine, 0, &inv_buf)); ndx = argstate->dyn.null_ndx; dyn = &argstate->dyn.data[ndx]; dyn->d_tag = d_tag; dyn->d_un.d_val = d_val; /* Recompute the DT_NULL situation */ set_null_ndx(argstate); return (ndx); } /* * Standard argument processing for dyn module * * entry * obj_state, argc, argv - Standard command arguments * argstate - Address of ARGSTATE block to be initialized * * exit: * On success, *argstate is initialized. On error, * an error is issued and this routine does not return. */ static void process_args(elfedit_obj_state_t *obj_state, int argc, const char *argv[], ARGSTATE *argstate) { elfedit_getopt_state_t getopt_state; elfedit_getopt_ret_t *getopt_ret; bzero(argstate, sizeof (*argstate)); argstate->obj_state = obj_state; elfedit_getopt_init(&getopt_state, &argc, &argv); /* Add each new option to the options mask */ while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL) { argstate->optmask |= getopt_ret->gor_idmask; switch (getopt_ret->gor_idmask) { case DYN_OPT_F_DYNNDX_VAL: case DYN_OPT_F_NEEDED: argstate->dyn_elt_str = getopt_ret->gor_value; break; } } /* If there may be an arbitrary amount of output, use a pager */ if (argc == 0) elfedit_pager_init(); /* Return the updated values of argc/argv */ argstate->argc = argc; argstate->argv = argv; /* Locate the dynamic section, and the assocated string table */ argstate->dyn.sec = elfedit_sec_getdyn(obj_state, &argstate->dyn.data, &argstate->dyn.num); argstate->strsec = elfedit_sec_getstr(obj_state, argstate->dyn.sec->sec_shdr->sh_link, 0); /* Index of first DT_NULL */ set_null_ndx(argstate); } /* * Print ELF header values, taking the calling command, and output style * into account. * * entry: * cmd - DYN_CMD_T_* value giving identify of caller * autoprint - If True, output is only produced if the elfedit * autoprint flag is set. If False, output is always produced. * argstate - Argument state block * print_type - Specifies which dynamic elements to display. * ndx = If print_type is PRINT_DYN_T_NDX, displays the index specified. * Otherwise ignored. */ typedef enum { PRINT_DYN_T_ALL = 0, /* Show all indexes */ PRINT_DYN_T_NDX = 1, /* Show dynamic[arg] only */ PRINT_DYN_T_TAG = 2, /* Show all elts with tag type */ /* given by arg */ PRINT_DYN_T_RUNPATH = 3 /* Show all runpath/rpath elts */ } PRINT_DYN_T; static void print_dyn(DYN_CMD_T cmd, int autoprint, ARGSTATE *argstate, PRINT_DYN_T print_type, Word arg) { elfedit_outstyle_t outstyle; Conv_fmt_flags_t flags_fmt_flags; Word end_ndx, ndx, printed = 0; Dyn *dyn; int header_done = 0; Xword last_d_val; int one_shot; if (autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0)) return; /* * Pick an output style. dyn:dump is required to use the default * style. The other commands use the current output style. */ outstyle = (cmd == DYN_CMD_T_DUMP) ? ELFEDIT_OUTSTYLE_DEFAULT : elfedit_outstyle(); /* * When using the simple output style, omit the * brackets from around the values. */ flags_fmt_flags = (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) ? CONV_FMT_NOBKT : 0; /* Starting index */ if (print_type == PRINT_DYN_T_NDX) { if (arg >= argstate->dyn.num) return; /* Out of range */ ndx = arg; } else { ndx = 0; } /* * one_shot is used by positional elements (e.g. DT_POSFLAG_1) * to get the item following them to be shown even if they * are not of the desired tag type or the count of elements * to be displayed is only 1. */ one_shot = 0; dyn = &argstate->dyn.data[ndx]; /* * Loop predicate explanation: * Normally, we want to iterate from the starting index * to the end. However, in the case of PRINT_DYN_T_NDX, we * only want to display one item (ndx == arg) and then quit, * with the exception that if we've been through the loop * and encountered a one_shot situation, we want to continue * iterating until the one-shot situation is cleared. */ for (; (ndx < argstate->dyn.num) && ((print_type != PRINT_DYN_T_NDX) || ((ndx == arg) || one_shot)); dyn++, ndx++) { union { Conv_inv_buf_t inv; Conv_dyn_flag_buf_t flag; Conv_dyn_flag1_buf_t flag1; Conv_dyn_posflag1_buf_t posflag1; Conv_dyn_feature1_buf_t feature1; } c_buf; const char *name; if (one_shot) { one_shot = 0; } else { /* * If we are only displaying certain tag types and * this isn't one of those, move on to next element. */ switch (print_type) { case PRINT_DYN_T_TAG: if (dyn->d_tag != arg) continue; break; case PRINT_DYN_T_RUNPATH: if ((dyn->d_tag != DT_RPATH) && (dyn->d_tag != DT_RUNPATH)) continue; break; } } /* * Print the information numerically, and if possible * as a string. */ name = NULL; switch (dyn->d_tag) { case DT_NULL: if (!((outstyle == ELFEDIT_OUTSTYLE_DEFAULT) && (print_type == PRINT_DYN_T_ALL) && (dyn->d_un.d_val == 0))) break; end_ndx = ndx; /* * Special case: DT_NULLs can come in groups * that we prefer to reduce to a single line. */ while ((end_ndx < (argstate->dyn.num - 1)) && ((dyn + 1)->d_tag == DT_NULL) && ((dyn + 1)->d_un.d_val == 0)) { dyn++; end_ndx++; } if (header_done == 0) { header_done = 1; Elf_dyn_title(0); } Elf_dyn_null_entry(0, dyn, ndx, end_ndx); ndx = end_ndx; printed = 1; last_d_val = dyn->d_un.d_val; continue; /* * Print the information numerically, and if possible * as a string. */ case DT_NEEDED: case DT_SONAME: case DT_FILTER: case DT_AUXILIARY: case DT_CONFIG: case DT_RPATH: case DT_RUNPATH: case DT_USED: case DT_DEPAUDIT: case DT_AUDIT: case DT_SUNW_AUXILIARY: case DT_SUNW_FILTER: name = elfedit_offset_to_str(argstate->strsec, dyn->d_un.d_val, ELFEDIT_MSG_DEBUG, 0); break; case DT_FLAGS: name = conv_dyn_flag(dyn->d_un.d_val, flags_fmt_flags, &c_buf.flag); break; case DT_FLAGS_1: name = conv_dyn_flag1(dyn->d_un.d_val, flags_fmt_flags, &c_buf.flag1); break; case DT_POSFLAG_1: /* * If this is dyn:posflag1, and the print_type * is PRINT_DYN_T_TAG, and the -needed option is * used, then don't show any DT_POSFLAG_1 elements * that are not followed by a DT_NEEDED element * that matches the -needed string. */ if ((cmd == DYN_CMD_T_POSFLAG1) && (print_type == PRINT_DYN_T_TAG) && ((argstate->optmask & DYN_OPT_F_NEEDED) != 0) && ((ndx + 1) < argstate->dyn.num)) { Dyn *dyn1 = &argstate->dyn.data[ndx + 1]; if (dyn1->d_tag != DT_NEEDED) continue; name = elfedit_offset_to_str(argstate->strsec, dyn1->d_un.d_val, ELFEDIT_MSG_DEBUG, 0); if (strncmp(name, argstate->dyn_elt_str, strlen(argstate->dyn_elt_str)) != 0) continue; } name = conv_dyn_posflag1(dyn->d_un.d_val, flags_fmt_flags, &c_buf.posflag1); /* * DT_POSFLAG_1 is a positional element that affects * the following item. If using the default output * style, then show the following item as well. */ one_shot = (outstyle == ELFEDIT_OUTSTYLE_DEFAULT); break; case DT_FEATURE_1: name = conv_dyn_feature1(dyn->d_un.d_val, flags_fmt_flags, &c_buf.feature1); break; case DT_DEPRECATED_SPARC_REGISTER: name = MSG_INTL(MSG_STR_DEPRECATED); break; case DT_SUNW_LDMACH: name = conv_ehdr_mach((Half)dyn->d_un.d_val, 0, &c_buf.inv); break; } if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) { if (header_done == 0) { header_done = 1; Elf_dyn_title(0); } if (name == NULL) name = MSG_ORIG(MSG_STR_EMPTY); Elf_dyn_entry(0, dyn, ndx, name, argstate->obj_state->os_ehdr->e_machine); } else { /* * In simple or numeric mode under a print type * that is based on tag type rather than on index, * if there are more than one qualifying tag, we * want to skip printing redundant information. */ switch (print_type) { case PRINT_DYN_T_TAG: switch (dyn->d_tag) { case DT_NEEDED: /* Multiple NEEDED entries are normal */ break; case DT_POSFLAG_1: /* * Positional flags don't count, * because each one affects a different * item. Don't skip those even if they * have duplicate values. */ break; default: /* * Anything else: If we've already * printed this value, don't print * it again. */ if (printed && (last_d_val == dyn->d_un.d_val)) continue; } break; case PRINT_DYN_T_RUNPATH: /* * If we've already printed this value, * don't print it again. This commonly * happens when both DT_RPATH and DT_RUNPATH * are present with the same value. */ if (printed && (last_d_val == dyn->d_un.d_val)) continue; break; } if ((name != NULL) && (outstyle == ELFEDIT_OUTSTYLE_SIMPLE)) { elfedit_printf(MSG_ORIG(MSG_FMT_STRNL), name); } else { elfedit_printf(MSG_ORIG(MSG_FMT_HEXXWORDNL), dyn->d_un.d_val); } } printed = 1; last_d_val = dyn->d_un.d_val; } /* * If nothing was output under the print types that are * based on tag type, issue an error saying it doesn't exist. */ if (!printed) { if (print_type == PRINT_DYN_T_TAG) { Conv_inv_buf_t inv_buf; elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NODYNELT), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, conv_dyn_tag(arg, argstate->obj_state->os_ehdr->e_machine, 0, &inv_buf)); } if (print_type == PRINT_DYN_T_RUNPATH) elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NORUNPATH), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name); } } /* * Determine the index(s) of the dynamic element(s) to be displayed and/or * manipulated. * * entry: * argstate - Argument state block * arg - If the command being called accepts a first plain argument * named 'elt' which is used to specify the dynamic element, * arg is the value of argv[0] for that command. If the * command does not accept an 'elt' argument and instead * implicitly assumes a tag type, arg is the constant string * for that type (e.g. "DT_POSFLAG_1"). * print_request - True if the command is to print the current * value(s) and return without changing anything. * print_type - Address of variable containing PRINT_DYN_T_ * code specifying how the elements will be displayed. * * exit: * If print_request is False: This routine always returns the index * of a single dynamic element. *print_type is set to PRINT_DYN_T_NDX. * The 'elt' argument as well as any modifier options (-dynndx, -needed) * are examined to determine this index. If there are no modifier options, * the dynamic section contains no element of the desired type, and there * is an extra DT_NULL element in the section, then a new element of * the desired type is created and its index returned. Otherwise an * error is issued. * * If print_request is True: If a modifier (-dynndx, -needed) was used, * *print_type is set to PRINT_DYN_T_NDX and the index of the * corresponding single dynamic element is returned. If no modifier * was used, *print_type is set to PRINT_DYN_T_TAG, and the tag * type code is returned. */ static Word arg_to_index(ARGSTATE *argstate, const char *arg, int print_request, PRINT_DYN_T *print_type) { Word ndx, dt_value; Dyn *dyn; /* Assume we are returning an index, alter as needed below */ *print_type = PRINT_DYN_T_NDX; /* * All the commands that accept the DYN_OPT_F_DYNNDX_ELT form * of -dynndx require a plain argument named 'elt' as their first * argument. -dynndx is a modifier that means that 'elt' is a * simple numeric section index. Routines that accept this form * of -dynndx are willing to handle any tag type, so all we need * to check is that the value is in range. */ if ((argstate->optmask & DYN_OPT_F_DYNNDX_ELT) != 0) return ((Word) elfedit_atoui_range(arg, MSG_ORIG(MSG_STR_ELT), 0, argstate->dyn.num - 1, NULL)); /* arg is a DT_ tag type, not a numeric index */ dt_value = (Word) elfedit_atoconst(arg, ELFEDIT_CONST_DT); /* * Commands that accept the DYN_OPT_F_DYNNDX_VAL form of * dynndx do not accept the 'elt' argument. The index is a * value that follows the option, and was saved in argstate by * process_args(). Routines that accept this form of -dynndx * require the specified element to have a specific tag type, * so we test for this as well as for the index being in range. */ if ((argstate->optmask & DYN_OPT_F_DYNNDX_VAL) != 0) { ndx = ((Word) elfedit_atoui_range(argstate->dyn_elt_str, MSG_ORIG(MSG_STR_INDEX), 0, argstate->dyn.num - 1, NULL)); if (argstate->dyn.data[ndx].d_tag != dt_value) { Half mach = argstate->obj_state->os_ehdr->e_machine; Conv_inv_buf_t is, want; elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_WRONGTAG), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, ndx, conv_dyn_tag(dt_value, mach, 0, &want), conv_dyn_tag(argstate->dyn.data[ndx].d_tag, mach, 0, &is)); } return (ndx); } /* * If this is a printing request, then we let print_dyn() show * all the items with this tag type. */ if (print_request) { *print_type = PRINT_DYN_T_TAG; return (dt_value); } /* * Commands that accept -needed are looking for the dt_value element * (usually DT_POSFLAG_1) that immediately preceeds the DT_NEEDED * element with the string given by argstate->dyn_elt_str. */ if ((argstate->optmask & DYN_OPT_F_NEEDED) != 0) { Word retndx = argstate->dyn.num; /* Out of range value */ const char *name; size_t len; len = strlen(argstate->dyn_elt_str); for (ndx = 0, dyn = argstate->dyn.data; ndx < argstate->dyn.num; dyn++, ndx++) { /* * If the immediately preceeding item has the * tag type we're looking for, and the current item * is a DT_NEEDED with a string that matches, * then the preceeding item is the one we want. */ if ((dyn->d_tag == DT_NEEDED) && (ndx > 0) && (retndx == (ndx - 1))) { name = elfedit_offset_to_str(argstate->strsec, dyn->d_un.d_val, ELFEDIT_MSG_DEBUG, 0); if (strncmp(name, argstate->dyn_elt_str, len) == 0) return (retndx); continue; } /* * If the current item has the tag type we're * looking for, make it our current candidate. * If the next item is a DT_NEEDED with the right * string value, we'll use it then. */ if (dyn->d_tag == dt_value) retndx = ndx; } /* If we get here, no matching DT_NEEDED was found */ elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NEEDEDNOMATCH), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, argstate->dyn_elt_str); } /* Locate the first entry with the given tag type */ for (ndx = 0; ndx < argstate->dyn.num; ndx++) { if (argstate->dyn.data[ndx].d_tag == dt_value) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_DT2NDX), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, EC_WORD(ndx), arg); return (ndx); } } /* Not found. Can we create one? */ if (argstate->dyn.num_null_ndx > 1) return (convert_dt_null(argstate, dt_value, 0)); /* No room to create one, so we're out of options and must fail */ elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NODTELT), EC_WORD(argstate->dyn.sec->sec_shndx), argstate->dyn.sec->sec_name, arg); /*NOTREACHED*/ return (0); /* For lint */ } /* * Called by cmd_body() for dyn:value. Implements the core functionality * for that command. * * This routine expects that both the index and value arguments are * present. */ static elfedit_cmdret_t cmd_body_value(ARGSTATE *argstate, Word *ret_ndx) { elfedit_section_t *dynsec = argstate->dyn.sec; elfedit_section_t *strsec = argstate->strsec; elfedit_dyn_elt_t strpad_elt; Word i; Dyn *dyn = argstate->dyn.data; Word numdyn = argstate->dyn.num; int minus_add, minus_s, minus_dynndx; Word arg1, tmp_val; Xword arg2; int arg2_known = 1; minus_add = ((argstate->optmask & DYN_OPT_F_ADD) != 0); minus_s = ((argstate->optmask & DYN_OPT_F_STRVAL) != 0); minus_dynndx = ((argstate->optmask & DYN_OPT_F_DYNNDX_ELT) != 0); elfedit_dyn_elt_init(&strpad_elt); /* * The first argument is an index if -dynndx is used, and is a * tag value otherwise. */ arg1 = minus_dynndx ? elfedit_atoui_range(argstate->argv[0], MSG_ORIG(MSG_STR_ELT), 0, numdyn - 1, NULL) : elfedit_atoconst(argstate->argv[0], ELFEDIT_CONST_DT); if (minus_s) { /* * Don't allow the user to specify -s when manipulating a * DT_SUNW_STRPAD element. Since DT_SUNW_STRPAD is used to * manage the extra space used for strings, this would break * our ability to add the string. */ if ((!minus_dynndx && (arg1 == DT_SUNW_STRPAD)) || (minus_dynndx && (dyn[arg1].d_tag == DT_SUNW_STRPAD))) elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_STRPADSTRVAL), EC_WORD(dynsec->sec_shndx), dynsec->sec_name); /* Locate DT_SUNW_STRPAD element if present */ strpad_elt.dn_dyn.d_un.d_val = 0; (void) elfedit_dynstr_getpad(argstate->dyn.sec, &strpad_elt); /* * Look up the string: If the user specified the -dynndx * -option, then we will insert it if possible, and * fail with an error if not. However, if they did not * specify -dynndx, we want to look up the string if it is * already there, but defer the insertion. The reason for * this is that we may have to grab an unused DT_NULL element * below, and if there are none available, we won't want * to have modified the string table. * * This isn't a problem, because if the string isn't * in the string table, it can't be used by a dynamic element. * Hence, we don't need to insert it to know that there is * no match. */ if (minus_dynndx == 0) { if (elfedit_sec_findstr(strsec, strpad_elt.dn_dyn.d_un.d_val, argstate->argv[1], &tmp_val) == 0) { arg2_known = 0; } else { arg2 = tmp_val; } } else { arg2 = elfedit_dynstr_insert(dynsec, strsec, &strpad_elt, argstate->argv[1]); } } else { /* Argument 2 is an integer */ arg2 = elfedit_atoui(argstate->argv[1], NULL); } if (!minus_dynndx && !(minus_add && !arg2_known)) { /* * Search the dynamic section and see if an item with the * specified tag value already exists. We can reduce this * to a simple update of an existing value if -add is not * specified or the existing d_un value matches the new one. * * In either of these cases, we will change arg1 to be the * index, and set minus_dynndx, causing the simple update to * happen immediately below. */ for (i = 0; i < numdyn; i++) { if ((dyn[i].d_tag == arg1) && (!minus_add || (dyn[i].d_un.d_val == arg2))) { arg1 = i; minus_dynndx = 1; break; } } } /* * If -dynndx is used, then this is a relatively simple * operation, as we simply write over the specified index. */ if (minus_dynndx) { /* * If we held back from inserting a new string into * the dynstr above, we insert it now, because we * have a slot in the dynamic section, and we need * the string offset ot finish. */ if (!arg2_known) arg2 = elfedit_dynstr_insert(dynsec, strsec, &strpad_elt, argstate->argv[1]); *ret_ndx = arg1; if (dyn[arg1].d_un.d_val == arg2) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_X_OK), dynsec->sec_shndx, dynsec->sec_name, EC_WORD(arg1), EC_XWORD(arg2)); return (ELFEDIT_CMDRET_NONE); } else { /* Warn if setting DT_NULL value to non-zero */ if ((dyn[arg1].d_tag == DT_NULL) && (arg2 != 0)) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_DTNULLVALUE), dynsec->sec_shndx, dynsec->sec_name, EC_WORD(arg1), EC_XWORD(arg2)); elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_X_CHG), dynsec->sec_shndx, dynsec->sec_name, EC_WORD(arg1), EC_XWORD(dyn[arg1].d_un.d_val), EC_XWORD(arg2)); dyn[arg1].d_un.d_val = arg2; return (ELFEDIT_CMDRET_MOD); } } /* * We need a new slot in the dynamic section. If we can't have * one, then we fail. */ if (argstate->dyn.num_null_ndx <= 1) elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOEXTRANULL), EC_WORD(dynsec->sec_shndx), dynsec->sec_name); /* * If we still need to insert a new string into the dynstr, * then it is safe now, because if we succeed, we know that * there is an available slot to receive it. If we fail, we * haven't claimed the extra slot yet, and it will be unharmed. */ if (!arg2_known) arg2 = elfedit_dynstr_insert(dynsec, strsec, &strpad_elt, argstate->argv[1]); /* Use an extra DT_NULL slot and enter the new element */ *ret_ndx = convert_dt_null(argstate, arg1, arg2); return (ELFEDIT_CMDRET_MOD); } /* * Called by cmd_body() for dyn:runpath. Implements the core functionality * for that command. * * History Lesson And Strategy: * * This routine handles both DT_RPATH and DT_RUNPATH entries, altering * either or both if they are present. * * The original SYSV ABI only had DT_RPATH, and the runtime loader used * it to search for things in the following order: * * DT_RPATH, LD_LIBRARY_PATH, defaults * * Solaris did not follow this rule, an extremely rare deviation from * the ABI. Environment variables should supercede everything else, * otherwise they are not very useful. This decision was made at the * very beginning of the SunOS 5.x development, so we have always * deviated from the ABI and and instead search in the order * * LD_LIBRARY_PATH, DT_RPATH, defaults * * Other Unix variants initially followed the ABI, but in recent years * have come to agree with the early Solaris folks that it was a mistake. * Hence, DT_RUNPATH was invented, with the search order: * * LD_LIBRARY_PATH, DT_RUNPATH, defaults * * So for Solaris, DT_RPATH and DT_RUNPATH mean the same thing. If both * are present (which does happen), we set them both to the new * value. If either one is present, we set that one. If neither is * present, and we have a spare DT_NULL slot, we create a DT_RUNPATH, but * not a DT_RPATH, to conserve available slots for other uses. */ static elfedit_cmdret_t cmd_body_runpath(ARGSTATE *argstate) { elfedit_section_t *dynsec = argstate->dyn.sec; elfedit_section_t *strsec = argstate->strsec; elfedit_dyn_elt_t rpath_elt; elfedit_dyn_elt_t runpath_elt; elfedit_dyn_elt_t strpad_elt; Word i; Dyn *dyn = argstate->dyn.data; Word numdyn = argstate->dyn.num; /* Go through the tags and gather what we need */ elfedit_dyn_elt_init(&rpath_elt); elfedit_dyn_elt_init(&runpath_elt); elfedit_dyn_elt_init(&strpad_elt); for (i = 0; i < numdyn; i++) { switch (dyn[i].d_tag) { case DT_RPATH: elfedit_dyn_elt_save(&rpath_elt, i, &dyn[i]); break; case DT_RUNPATH: elfedit_dyn_elt_save(&runpath_elt, i, &dyn[i]); break; case DT_SUNW_STRPAD: elfedit_dyn_elt_save(&strpad_elt, i, &dyn[i]); break; } } /* Do we have an available dynamic section entry to use? */ if (rpath_elt.dn_seen || runpath_elt.dn_seen) { /* * We have seen a DT_RPATH, or a DT_RUNPATH, or both. * If all of these have the same string as the desired * new value, then we don't need to alter anything and can * simply return. Otherwise, we'll modify them all to have * the new string (below). */ if ((!rpath_elt.dn_seen || (strcmp(elfedit_dyn_offset_to_str(strsec, &rpath_elt), argstate->argv[0]) == 0)) && (!runpath_elt.dn_seen || (strcmp(elfedit_dyn_offset_to_str(strsec, &runpath_elt), argstate->argv[0]) == 0))) { if (rpath_elt.dn_seen) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_OLDRPATHOK), EC_WORD(dynsec->sec_shndx), dynsec->sec_name, EC_WORD(rpath_elt.dn_ndx), elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_RPATH, 1)); if (runpath_elt.dn_seen) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_OLDRPATHOK), EC_WORD(dynsec->sec_shndx), dynsec->sec_name, EC_WORD(runpath_elt.dn_ndx), elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_RUNPATH, 1)); return (ELFEDIT_CMDRET_NONE); } } else if (argstate->dyn.num_null_ndx <= 1) { /* * There is no DT_RPATH or DT_RUNPATH in the dynamic array, * and there are no extra DT_NULL entries that we can * convert into one. We cannot proceed. */ elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOEXTRANULL), EC_WORD(dynsec->sec_shndx), dynsec->sec_name); } /* Does the string exist in the table already, or can we add it? */ rpath_elt.dn_dyn.d_un.d_val = runpath_elt.dn_dyn.d_un.d_val = elfedit_dynstr_insert(dynsec, strsec, &strpad_elt, argstate->argv[0]); /* Update DT_RPATH entry if present */ if (rpath_elt.dn_seen) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_PREVRPATH), EC_WORD(dynsec->sec_shndx), dynsec->sec_name, EC_WORD(rpath_elt.dn_ndx), elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_RPATH, 1), elfedit_dyn_offset_to_str(strsec, &rpath_elt)); dyn[rpath_elt.dn_ndx] = rpath_elt.dn_dyn; } /* * Update the DT_RUNPATH entry in the dynamic section, if present. * If one is not present, and there is also no DT_RPATH, then * we use a spare DT_NULL entry to create a new DT_RUNPATH. */ if (runpath_elt.dn_seen || !rpath_elt.dn_seen) { if (runpath_elt.dn_seen) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_PREVRPATH), EC_WORD(dynsec->sec_shndx), dynsec->sec_name, EC_WORD(runpath_elt.dn_ndx), elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_RUNPATH, 1), elfedit_dyn_offset_to_str(strsec, &runpath_elt)); dyn[runpath_elt.dn_ndx] = runpath_elt.dn_dyn; } else { /* Using a spare DT_NULL entry */ (void) convert_dt_null(argstate, DT_RUNPATH, runpath_elt.dn_dyn.d_un.d_val); } } return (ELFEDIT_CMDRET_MOD); } /* * Argument processing for the bitmask commands. Convert the arguments * to integer form, apply -and/-cmp/-or, and return the resulting value. * * entry: * argstate - Argument state block * orig - Value of original bitmask * const_type - ELFEDIT_CONST_* value for type of constants */ static Word flag_bitop(ARGSTATE *argstate, Word orig, elfedit_const_t const_type) { Word flags = 0; int i; /* Collect the arguments */ for (i = 0; i < argstate->argc; i++) flags |= (Word) elfedit_atoconst(argstate->argv[i], const_type); /* Complement the value? */ if (argstate->optmask & DYN_OPT_F_CMP) flags = ~flags; /* Perform any requested bit operations */ if (argstate->optmask & DYN_OPT_F_AND) flags &= orig; else if (argstate->optmask & DYN_OPT_F_OR) flags |= orig; return (flags); } /* * Common body for the dyn: module commands. These commands * share a large amount of common behavior, so it is convenient * to centralize things and use the cmd argument to handle the * small differences. * * entry: * cmd - One of the DYN_CMD_T_* constants listed above, specifying * which command to implement. * obj_state, argc, argv - Standard command arguments */ static elfedit_cmdret_t cmd_body(DYN_CMD_T cmd, elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { ARGSTATE argstate; Dyn *dyn; const char *dyn_name; Word dyn_ndx, dyn_num, null_ndx; elfedit_cmdret_t ret = ELFEDIT_CMDRET_NONE; PRINT_DYN_T print_type = PRINT_DYN_T_ALL; Word ndx; int print_only = 0; int do_autoprint = 1; /* Process the optional arguments */ process_args(obj_state, argc, argv, &argstate); dyn = argstate.dyn.data; dyn_num = argstate.dyn.num; dyn_name = argstate.dyn.sec->sec_name; dyn_ndx = argstate.dyn.sec->sec_shndx; /* Check number of arguments, gather information */ switch (cmd) { case DYN_CMD_T_DUMP: /* dyn:dump can accept an optional index argument */ if (argstate.argc > 1) elfedit_command_usage(); print_only = 1; if (argstate.argc == 1) ndx = arg_to_index(&argstate, argstate.argv[0], print_only, &print_type); break; case DYN_CMD_T_TAG: print_only = (argstate.argc != 2); if (argstate.argc > 0) { if (argstate.argc > 2) elfedit_command_usage(); ndx = arg_to_index(&argstate, argstate.argv[0], print_only, &print_type); } break; case DYN_CMD_T_VALUE: print_only = (argstate.argc != 2); if (argstate.argc > 2) elfedit_command_usage(); if (argstate.argc > 0) { if (print_only) { ndx = arg_to_index(&argstate, argstate.argv[0], print_only, &print_type); } else { print_type = PRINT_DYN_T_NDX; } } break; case DYN_CMD_T_DELETE: if ((argstate.argc < 1) || (argstate.argc > 2)) elfedit_command_usage(); ndx = arg_to_index(&argstate, argstate.argv[0], 0, &print_type); do_autoprint = 0; break; case DYN_CMD_T_MOVE: if ((argstate.argc < 2) || (argstate.argc > 3)) elfedit_command_usage(); ndx = arg_to_index(&argstate, argstate.argv[0], 0, &print_type); do_autoprint = 0; break; case DYN_CMD_T_RUNPATH: if (argstate.argc > 1) elfedit_command_usage(); /* * dyn:runpath does not accept an explicit index * argument, so we implicitly only show the DT_RPATH and * DT_RUNPATH elements. */ print_type = PRINT_DYN_T_RUNPATH; print_only = (argstate.argc == 0); break; case DYN_CMD_T_POSFLAG1: print_only = (argstate.argc == 0); ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_POSFLAG_1, 1), print_only, &print_type); break; case DYN_CMD_T_FLAGS: print_only = (argstate.argc == 0); ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_FLAGS, 1), print_only, &print_type); break; case DYN_CMD_T_FLAGS1: print_only = (argstate.argc == 0); ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_FLAGS_1, 1), print_only, &print_type); break; case DYN_CMD_T_FEATURE1: print_only = (argstate.argc == 0); ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_FEATURE_1, 1), print_only, &print_type); break; case DYN_CMD_T_CHECKSUM: ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_CHECKSUM, 1), print_only, &print_type); break; case DYN_CMD_T_SUNW_LDMACH: if (argstate.argc > 1) elfedit_command_usage(); print_only = (argstate.argc == 0); ndx = arg_to_index(&argstate, elfedit_atoconst_value_to_str( ELFEDIT_CONST_DT, DT_SUNW_LDMACH, 1), print_only, &print_type); break; default: /* Note expected: All commands should have been caught above */ elfedit_command_usage(); break; } /* If this is a request to print current values, do it and return */ if (print_only) { print_dyn(cmd, 0, &argstate, print_type, ndx); return (ELFEDIT_CMDRET_NONE); } switch (cmd) { /* * DYN_CMD_T_DUMP can't get here: It is a print-only * command. */ case DYN_CMD_T_TAG: { Conv_inv_buf_t inv_buf1, inv_buf2; Half mach = argstate.obj_state->os_ehdr->e_machine; Word d_tag = (Word) elfedit_atoconst(argstate.argv[1], ELFEDIT_CONST_DT); if (dyn[ndx].d_tag == d_tag) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_tag(d_tag, mach, 0, &inv_buf1)); } else { Word orig_d_tag = dyn[ndx].d_tag; ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_tag = d_tag; /* * Update null termination index. Warn if we * just clobbered the only DT_NULL termination * for the array. */ null_ndx = argstate.dyn.null_ndx; set_null_ndx(&argstate); if ((argstate.dyn.null_ndx >= argstate.dyn.num) && (null_ndx != argstate.dyn.null_ndx)) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_NULLTERM), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_tag(d_tag, mach, 0, &inv_buf1)); /* * Warning if * - Inserting a DT_NULL cuts off following * non-null elements. * - Inserting a non-DT_NULL after the * first null element, will be * ignored by rtld. */ if (d_tag == DT_NULL) { if ((ndx + 1) < null_ndx) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_NULCLIP), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_tag(d_tag, mach, 0, &inv_buf1)); } else { if ((ndx + 1) > argstate.dyn.null_ndx) elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_NULHIDE), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_tag(d_tag, mach, 0, &inv_buf1)); } /* Debug message that we changed it */ elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_tag(orig_d_tag, mach, 0, &inv_buf1), conv_dyn_tag(d_tag, mach, 0, &inv_buf2)); } } break; case DYN_CMD_T_VALUE: ret = cmd_body_value(&argstate, &ndx); break; case DYN_CMD_T_DELETE: { Word cnt = (argstate.argc == 1) ? 1 : (Word) elfedit_atoui_range(argstate.argv[1], MSG_ORIG(MSG_STR_COUNT), 1, dyn_num - ndx, NULL); const char *msg_prefix = elfedit_sec_msgprefix(argstate.dyn.sec); elfedit_array_elts_delete(msg_prefix, argstate.dyn.data, sizeof (Dyn), dyn_num, ndx, cnt); ret = ELFEDIT_CMDRET_MOD; } break; case DYN_CMD_T_MOVE: { Dyn save; Word cnt; Word dstndx; const char *msg_prefix = elfedit_sec_msgprefix(argstate.dyn.sec); dstndx = (Word) elfedit_atoui_range(argstate.argv[1], MSG_ORIG(MSG_STR_DST_INDEX), 0, dyn_num - 1, NULL); if (argstate.argc == 2) { cnt = 1; } else { cnt = (Word) elfedit_atoui_range( argstate.argv[2], MSG_ORIG(MSG_STR_COUNT), 1, dyn_num, NULL); } elfedit_array_elts_move(msg_prefix, argstate.dyn.data, sizeof (save), dyn_num, ndx, dstndx, cnt, &save); ret = ELFEDIT_CMDRET_MOD; } break; case DYN_CMD_T_RUNPATH: ret = cmd_body_runpath(&argstate); break; case DYN_CMD_T_POSFLAG1: { Conv_dyn_posflag1_buf_t buf1, buf2; Word flags; flags = flag_bitop(&argstate, dyn[ndx].d_un.d_val, ELFEDIT_CONST_DF_P1); /* Set the value */ if (dyn[ndx].d_un.d_val == flags) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_posflag1(dyn[ndx].d_un.d_val, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_posflag1(dyn[ndx].d_un.d_val, 0, &buf1), conv_dyn_posflag1(flags, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = flags; } } break; case DYN_CMD_T_FLAGS: { Conv_dyn_flag_buf_t buf1, buf2; Word flags; flags = flag_bitop(&argstate, dyn[ndx].d_un.d_val, ELFEDIT_CONST_DF); /* Set the value */ if (dyn[ndx].d_un.d_val == flags) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_flag(dyn[ndx].d_un.d_val, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_flag(dyn[ndx].d_un.d_val, 0, &buf1), conv_dyn_flag(flags, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = flags; } } break; case DYN_CMD_T_FLAGS1: { Conv_dyn_flag1_buf_t buf1, buf2; Word flags1; flags1 = flag_bitop(&argstate, dyn[ndx].d_un.d_val, ELFEDIT_CONST_DF_1); /* Set the value */ if (dyn[ndx].d_un.d_val == flags1) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_flag1(dyn[ndx].d_un.d_val, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_flag1(dyn[ndx].d_un.d_val, 0, &buf1), conv_dyn_flag1(flags1, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = flags1; } } break; case DYN_CMD_T_FEATURE1: { Conv_dyn_feature1_buf_t buf1, buf2; Word flags; flags = flag_bitop(&argstate, dyn[ndx].d_un.d_val, ELFEDIT_CONST_DTF_1); /* Set the value */ if (dyn[ndx].d_un.d_val == flags) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_feature1(dyn[ndx].d_un.d_val, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_dyn_feature1(dyn[ndx].d_un.d_val, 0, &buf1), conv_dyn_feature1(flags, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = flags; } } break; case DYN_CMD_T_CHECKSUM: { long checksum = elf_checksum(obj_state->os_elf); /* Set the value */ if (dyn[ndx].d_un.d_val == checksum) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_X_OK), dyn_ndx, dyn_name, EC_WORD(ndx), EC_XWORD(checksum)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_X_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), EC_XWORD(dyn[ndx].d_un.d_val), EC_XWORD(checksum)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = checksum; } } break; case DYN_CMD_T_SUNW_LDMACH: { Conv_inv_buf_t buf1, buf2; Half ldmach; ldmach = (Half) elfedit_atoconst(argstate.argv[0], ELFEDIT_CONST_EM); /* Set the value */ if (dyn[ndx].d_un.d_val == ldmach) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), dyn_ndx, dyn_name, EC_WORD(ndx), conv_ehdr_mach(dyn[ndx].d_un.d_val, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), dyn_ndx, dyn_name, EC_WORD(ndx), conv_ehdr_mach(dyn[ndx].d_un.d_val, 0, &buf1), conv_ehdr_mach(ldmach, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; dyn[ndx].d_un.d_val = ldmach; } } break; } /* * If we modified the dynamic section header, tell libelf. */ if (ret == ELFEDIT_CMDRET_MOD) elfedit_modified_data(argstate.dyn.sec); /* Do autoprint */ if (do_autoprint) print_dyn(cmd, 1, &argstate, print_type, ndx); return (ret); } /* * Command completion functions for the commands */ /* * Command completion for the first argument, which specifies * the dynamic element to use. Examines the options to see if * -dynndx is present, and if not, supplies the completion * strings for argument 1. */ /*ARGSUSED*/ static void cpl_eltarg(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { elfedit_section_t *cache; Dyn *dyn; Word i; const char *s; char *s2; char buf[128]; /* Make sure it's the first argument */ if ((argc - num_opt) != 1) return; /* Is -dynndx present? If so, we don't complete tag types */ for (i = 0; i < num_opt; i++) if (strcmp(argv[i], MSG_ORIG(MSG_STR_MINUS_DYNNDX)) == 0) return; /* * If there is no object, or if there is no dynamic section, * then supply all possible names. */ if ((obj_state == NULL) || (obj_state->os_dynndx == SHN_UNDEF)) { elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DT); return; } /* Supply completions for the tags present in the dynamic section */ cache = &obj_state->os_secarr[obj_state->os_dynndx]; dyn = (Dyn *) cache->sec_data->d_buf; i = cache->sec_shdr->sh_size / cache->sec_shdr->sh_entsize; for (; i-- > 0; dyn++) { s = elfedit_atoconst_value_to_str(ELFEDIT_CONST_DT, dyn->d_tag, 0); if (s == NULL) continue; elfedit_cpl_match(cpldata, s, 1); /* * To get the informal tag names that are lowercase * and lack the leading DT_, we copy the string we * have into a buffer and process it. */ if (strlen(s) < 3) continue; (void) strlcpy(buf, s + 3, sizeof (buf)); for (s2 = buf; *s2 != '\0'; s2++) if (isupper(*s2)) *s2 = tolower(*s2); elfedit_cpl_match(cpldata, buf, 1); } } /*ARGSUSED*/ static void cpl_tag(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* First argument */ if ((argc - num_opt) == 1) { cpl_eltarg(obj_state, cpldata, argc, argv, num_opt); return; } /* The second argument is always a tag value */ if ((argc - num_opt) == 2) elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DT); } /*ARGSUSED*/ static void cpl_posflag1(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* * dyn:posflag1 accepts two mutually exclusive options that have * a corresponding value argument: -dynndx and -needed. If we * are being called to supply options for the value, handle that here. */ if ((num_opt > 1) && (argc == num_opt)) { elfedit_section_t *dynsec, *strsec; const char *opt = argv[num_opt - 2]; dyn_opt_t type; Dyn *dyn; Word i, num; /* * If there is no object available, or if the object has no * dynamic section, then there is nothing to report. */ if ((obj_state == NULL) || obj_state->os_dynndx == SHN_UNDEF) return; /* * Determine which option it is, bail if it isn't one of * the ones we are concerned with. */ if ((strcmp(opt, MSG_ORIG(MSG_STR_MINUS_NEEDED)) == 0)) type = DYN_OPT_F_NEEDED; else if ((strcmp(opt, MSG_ORIG(MSG_STR_MINUS_DYNNDX)) == 0)) type = DYN_OPT_F_DYNNDX_VAL; else return; dynsec = elfedit_sec_getdyn(obj_state, &dyn, &num); switch (type) { case DYN_OPT_F_NEEDED: strsec = elfedit_sec_getstr(obj_state, dynsec->sec_shdr->sh_link, 0); for (; num-- > 0; dyn++) if (dyn->d_tag == DT_NEEDED) elfedit_cpl_match(cpldata, elfedit_offset_to_str(strsec, dyn->d_un.d_val, ELFEDIT_MSG_DEBUG, 0), 0); break; case DYN_OPT_F_DYNNDX_VAL: for (i = 0; i < num; i++, dyn++) if (dyn->d_tag == DT_POSFLAG_1) elfedit_cpl_ndx(cpldata, i); break; } return; } /* This routine allows multiple flags to be specified */ elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DF_P1); } /*ARGSUSED*/ static void cpl_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* This routine allows multiple flags to be specified */ elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DF); } /*ARGSUSED*/ static void cpl_flags1(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* This routine allows multiple flags to be specified */ elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DF_1); } /*ARGSUSED*/ static void cpl_feature1(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* This routine allows multiple flags to be specified */ elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_DTF_1); } /*ARGSUSED*/ static void cpl_sunw_ldmach(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* * This command doesn't accept options, so num_opt should be * 0. This is a defensive measure, in case that should change. */ argc -= num_opt; argv += num_opt; if (argc == 1) elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_EM); } /* * Implementation functions for the commands */ static elfedit_cmdret_t cmd_dump(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_DUMP, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_tag(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_TAG, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_value(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_VALUE, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_delete(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_DELETE, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_move(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_MOVE, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_runpath(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_RUNPATH, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_posflag1(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_POSFLAG1, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_flags(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_FLAGS, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_flags1(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_FLAGS1, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_feature1(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_FEATURE1, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_checksum(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_CHECKSUM, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_sunw_ldmach(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(DYN_CMD_T_SUNW_LDMACH, obj_state, argc, argv)); } /*ARGSUSED*/ elfedit_module_t * elfedit_init(elfedit_module_version_t version) { /* For commands that only accept -o */ static elfedit_cmd_optarg_t opt_ostyle[] = { { ELFEDIT_STDOA_OPT_O, NULL, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { NULL } }; /* For commands that only accept -and, -cmp, -o, -or */ static elfedit_cmd_optarg_t opt_ostyle_bitop[] = { { ELFEDIT_STDOA_OPT_AND, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_AND, DYN_OPT_F_OR }, { ELFEDIT_STDOA_OPT_CMP, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_CMP, 0 }, { ELFEDIT_STDOA_OPT_O, NULL, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { ELFEDIT_STDOA_OPT_OR, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_OR, DYN_OPT_F_AND }, { NULL } }; /* For commands that only accept -dynndx */ static elfedit_cmd_optarg_t opt_minus_dynndx[] = { { MSG_ORIG(MSG_STR_MINUS_DYNNDX), /* MSG_INTL(MSG_OPTDESC_DYNNDX_ELT) */ ELFEDIT_I18NHDL(MSG_OPTDESC_DYNNDX_ELT), 0, DYN_OPT_F_DYNNDX_ELT, 0 }, { NULL } }; /* dyn:dump */ static const char *name_dump[] = { MSG_ORIG(MSG_CMD_DUMP), MSG_ORIG(MSG_STR_EMPTY), /* "" makes this the default command */ NULL }; static elfedit_cmd_optarg_t arg_dump[] = { { MSG_ORIG(MSG_STR_ELT), /* MSG_INTL(MSG_ARGDESC_ELT) */ ELFEDIT_I18NHDL(MSG_ARGDESC_ELT), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:tag */ static const char *name_tag[] = { MSG_ORIG(MSG_CMD_TAG), NULL }; static elfedit_cmd_optarg_t opt_tag[] = { { MSG_ORIG(MSG_STR_MINUS_DYNNDX), /* MSG_INTL(MSG_OPTDESC_DYNNDX_ELT) */ ELFEDIT_I18NHDL(MSG_OPTDESC_DYNNDX_ELT), 0, DYN_OPT_F_DYNNDX_ELT, 0 }, { ELFEDIT_STDOA_OPT_O, NULL, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { NULL } }; static elfedit_cmd_optarg_t arg_tag[] = { { MSG_ORIG(MSG_STR_ELT), /* MSG_INTL(MSG_A1_TAG_ELT) */ ELFEDIT_I18NHDL(MSG_A1_TAG_ELT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A2_TAG_VALUE) */ ELFEDIT_I18NHDL(MSG_A2_TAG_VALUE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:value */ static const char *name_value[] = { MSG_ORIG(MSG_CMD_VALUE), NULL }; static elfedit_cmd_optarg_t opt_value[] = { { MSG_ORIG(MSG_STR_MINUS_ADD), /* MSG_INTL(MSG_OPTDESC_ADD) */ ELFEDIT_I18NHDL(MSG_OPTDESC_ADD), 0, DYN_OPT_F_ADD, DYN_OPT_F_DYNNDX_ELT }, { MSG_ORIG(MSG_STR_MINUS_DYNNDX), /* MSG_INTL(MSG_OPTDESC_DYNNDX_ELT) */ ELFEDIT_I18NHDL(MSG_OPTDESC_DYNNDX_ELT), 0, DYN_OPT_F_DYNNDX_ELT, DYN_OPT_F_ADD }, { ELFEDIT_STDOA_OPT_O, NULL, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { MSG_ORIG(MSG_STR_MINUS_S), /* MSG_INTL(MSG_OPTDESC_S) */ ELFEDIT_I18NHDL(MSG_OPTDESC_S), 0, DYN_OPT_F_STRVAL, 0 }, { NULL } }; static elfedit_cmd_optarg_t arg_value[] = { { MSG_ORIG(MSG_STR_ELT), /* MSG_INTL(MSG_ARGDESC_ELT) */ ELFEDIT_I18NHDL(MSG_ARGDESC_ELT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A2_VALUE_VALUE) */ ELFEDIT_I18NHDL(MSG_A2_VALUE_VALUE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:delete */ static const char *name_delete[] = { MSG_ORIG(MSG_CMD_DELETE), NULL }; static elfedit_cmd_optarg_t arg_delete[] = { { MSG_ORIG(MSG_STR_ELT), /* MSG_INTL(MSG_ARGDESC_ELT) */ ELFEDIT_I18NHDL(MSG_ARGDESC_ELT), 0 }, { MSG_ORIG(MSG_STR_COUNT), /* MSG_INTL(MSG_A2_DELETE_COUNT) */ ELFEDIT_I18NHDL(MSG_A2_DELETE_COUNT), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:move */ static const char *name_move[] = { MSG_ORIG(MSG_CMD_MOVE), NULL }; static elfedit_cmd_optarg_t arg_move[] = { { MSG_ORIG(MSG_STR_ELT), /* MSG_INTL(MSG_ARGDESC_ELT) */ ELFEDIT_I18NHDL(MSG_ARGDESC_ELT), 0 }, { MSG_ORIG(MSG_STR_DST_INDEX), /* MSG_INTL(MSG_A2_MOVE_DST_INDEX) */ ELFEDIT_I18NHDL(MSG_A2_MOVE_DST_INDEX), 0 }, { MSG_ORIG(MSG_STR_COUNT), /* MSG_INTL(MSG_A3_MOVE_COUNT) */ ELFEDIT_I18NHDL(MSG_A3_MOVE_COUNT), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:runpath / dyn:rpath */ static const char *name_runpath[] = { MSG_ORIG(MSG_CMD_RUNPATH), MSG_ORIG(MSG_CMD_RUNPATH_A1), NULL }; static elfedit_cmd_optarg_t arg_runpath[] = { { MSG_ORIG(MSG_STR_NEWPATH), /* MSG_INTL(MSG_A1_RUNPATH_NEWPATH) */ ELFEDIT_I18NHDL(MSG_A1_RUNPATH_NEWPATH), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* dyn:posflag1 */ static const char *name_posflag1[] = { MSG_ORIG(MSG_CMD_POSFLAG1), NULL }; static elfedit_cmd_optarg_t opt_posflag1[] = { { ELFEDIT_STDOA_OPT_AND, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_AND, DYN_OPT_F_OR }, { ELFEDIT_STDOA_OPT_CMP, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_CMP, 0 }, { MSG_ORIG(MSG_STR_MINUS_DYNNDX), /* MSG_INTL(MSG_OPTDESC_DYNNDX_VAL) */ ELFEDIT_I18NHDL(MSG_OPTDESC_DYNNDX_VAL), ELFEDIT_CMDOA_F_VALUE, DYN_OPT_F_DYNNDX_VAL, DYN_OPT_F_NEEDED }, { MSG_ORIG(MSG_STR_INDEX), NULL, 0, 0 }, { MSG_ORIG(MSG_STR_MINUS_NEEDED), /* MSG_INTL(MSG_OPTDESC_NEEDED) */ ELFEDIT_I18NHDL(MSG_OPTDESC_NEEDED), ELFEDIT_CMDOA_F_VALUE, DYN_OPT_F_NEEDED, DYN_OPT_F_DYNNDX_VAL }, { MSG_ORIG(MSG_STR_PREFIX), NULL, 0, 0 }, { ELFEDIT_STDOA_OPT_O, NULL, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { ELFEDIT_STDOA_OPT_OR, NULL, ELFEDIT_CMDOA_F_INHERIT, DYN_OPT_F_OR, DYN_OPT_F_AND }, { NULL } }; static elfedit_cmd_optarg_t arg_posflag1[] = { { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A1_POSFLAG1_VALUE) */ ELFEDIT_I18NHDL(MSG_A1_POSFLAG1_VALUE), ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT }, { NULL } }; /* dyn:flags */ static const char *name_flags[] = { MSG_ORIG(MSG_CMD_FLAGS), NULL }; static elfedit_cmd_optarg_t arg_flags[] = { { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A1_FLAGS_VALUE) */ ELFEDIT_I18NHDL(MSG_A1_FLAGS_VALUE), ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT }, { NULL } }; /* dyn:flags1 */ static const char *name_flags1[] = { MSG_ORIG(MSG_CMD_FLAGS1), NULL }; static elfedit_cmd_optarg_t arg_flags1[] = { { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A1_FLAGS1_VALUE) */ ELFEDIT_I18NHDL(MSG_A1_FLAGS1_VALUE), ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT }, { NULL } }; /* dyn:feature1 */ static const char *name_feature1[] = { MSG_ORIG(MSG_CMD_FEATURE1), NULL }; static elfedit_cmd_optarg_t arg_feature1[] = { { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A1_FEATURE1_VALUE) */ ELFEDIT_I18NHDL(MSG_A1_FEATURE1_VALUE), ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT }, { NULL } }; /* dyn:checksum */ static const char *name_checksum[] = { MSG_ORIG(MSG_CMD_CHECKSUM), NULL }; /* dyn:sunw_ldmach */ static const char *name_sunw_ldmach[] = { MSG_ORIG(MSG_CMD_SUNW_LDMACH), NULL }; static elfedit_cmd_optarg_t arg_sunw_ldmach[] = { { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A1_SUNW_LDMACH_VALUE) */ ELFEDIT_I18NHDL(MSG_A1_SUNW_LDMACH_VALUE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; static elfedit_cmd_t cmds[] = { /* dyn:dump */ { cmd_dump, cpl_eltarg, name_dump, /* MSG_INTL(MSG_DESC_DUMP) */ ELFEDIT_I18NHDL(MSG_DESC_DUMP), /* MSG_INTL(MSG_HELP_DUMP) */ ELFEDIT_I18NHDL(MSG_HELP_DUMP), opt_minus_dynndx, arg_dump }, /* dyn:tag */ { cmd_tag, cpl_tag, name_tag, /* MSG_INTL(MSG_DESC_TAG) */ ELFEDIT_I18NHDL(MSG_DESC_TAG), /* MSG_INTL(MSG_HELP_TAG) */ ELFEDIT_I18NHDL(MSG_HELP_TAG), opt_tag, arg_tag }, /* dyn:value */ { cmd_value, cpl_eltarg, name_value, /* MSG_INTL(MSG_DESC_VALUE) */ ELFEDIT_I18NHDL(MSG_DESC_VALUE), /* MSG_INTL(MSG_HELP_VALUE) */ ELFEDIT_I18NHDL(MSG_HELP_VALUE), opt_value, arg_value }, /* dyn:delete */ { cmd_delete, cpl_eltarg, name_delete, /* MSG_INTL(MSG_DESC_DELETE) */ ELFEDIT_I18NHDL(MSG_DESC_DELETE), /* MSG_INTL(MSG_HELP_DELETE) */ ELFEDIT_I18NHDL(MSG_HELP_DELETE), opt_minus_dynndx, arg_delete }, /* dyn:move */ { cmd_move, cpl_eltarg, name_move, /* MSG_INTL(MSG_DESC_MOVE) */ ELFEDIT_I18NHDL(MSG_DESC_MOVE), /* MSG_INTL(MSG_HELP_MOVE) */ ELFEDIT_I18NHDL(MSG_HELP_MOVE), opt_minus_dynndx, arg_move }, /* dyn:runpath */ { cmd_runpath, NULL, name_runpath, /* MSG_INTL(MSG_DESC_RUNPATH) */ ELFEDIT_I18NHDL(MSG_DESC_RUNPATH), /* MSG_INTL(MSG_HELP_RUNPATH) */ ELFEDIT_I18NHDL(MSG_HELP_RUNPATH), opt_ostyle, arg_runpath }, /* dyn:posflag1 */ { cmd_posflag1, cpl_posflag1, name_posflag1, /* MSG_INTL(MSG_DESC_POSFLAG1) */ ELFEDIT_I18NHDL(MSG_DESC_POSFLAG1), /* MSG_INTL(MSG_HELP_POSFLAG1) */ ELFEDIT_I18NHDL(MSG_HELP_POSFLAG1), opt_posflag1, arg_posflag1 }, /* dyn:flags */ { cmd_flags, cpl_flags, name_flags, /* MSG_INTL(MSG_DESC_FLAGS) */ ELFEDIT_I18NHDL(MSG_DESC_FLAGS), /* MSG_INTL(MSG_HELP_FLAGS) */ ELFEDIT_I18NHDL(MSG_HELP_FLAGS), opt_ostyle_bitop, arg_flags }, /* dyn:flags1 */ { cmd_flags1, cpl_flags1, name_flags1, /* MSG_INTL(MSG_DESC_FLAGS1) */ ELFEDIT_I18NHDL(MSG_DESC_FLAGS1), /* MSG_INTL(MSG_HELP_FLAGS1) */ ELFEDIT_I18NHDL(MSG_HELP_FLAGS1), opt_ostyle_bitop, arg_flags1 }, /* dyn:feature1 */ { cmd_feature1, cpl_feature1, name_feature1, /* MSG_INTL(MSG_DESC_FEATURE1) */ ELFEDIT_I18NHDL(MSG_DESC_FEATURE1), /* MSG_INTL(MSG_HELP_FEATURE1) */ ELFEDIT_I18NHDL(MSG_HELP_FEATURE1), opt_ostyle_bitop, arg_feature1 }, /* dyn:checksum */ { cmd_checksum, NULL, name_checksum, /* MSG_INTL(MSG_DESC_CHECKSUM) */ ELFEDIT_I18NHDL(MSG_DESC_CHECKSUM), /* MSG_INTL(MSG_HELP_CHECKSUM) */ ELFEDIT_I18NHDL(MSG_HELP_CHECKSUM), NULL, NULL }, /* dyn:sunw_ldmach */ { cmd_sunw_ldmach, cpl_sunw_ldmach, name_sunw_ldmach, /* MSG_INTL(MSG_DESC_SUNW_LDMACH) */ ELFEDIT_I18NHDL(MSG_DESC_SUNW_LDMACH), /* MSG_INTL(MSG_HELP_SUNW_LDMACH) */ ELFEDIT_I18NHDL(MSG_HELP_SUNW_LDMACH), opt_ostyle, arg_sunw_ldmach }, { NULL } }; static elfedit_module_t module = { ELFEDIT_VER_CURRENT, MSG_ORIG(MSG_MOD_NAME), /* MSG_INTL(MSG_MOD_DESC) */ ELFEDIT_I18NHDL(MSG_MOD_DESC), cmds, mod_i18nhdl_to_str }; return (&module); }