/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include #include #include #include #include /* * Program headers */ /* * 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 */ PHDR_CMD_T_DUMP = 0, /* phdr:dump */ /* Commands that correspond directly to program header fields */ PHDR_CMD_T_P_TYPE = 1, /* phdr:p_type */ PHDR_CMD_T_P_OFFSET = 2, /* phdr:p_offset */ PHDR_CMD_T_P_VADDR = 3, /* phdr:p_vaddr */ PHDR_CMD_T_P_PADDR = 4, /* phdr:p_paddr */ PHDR_CMD_T_P_FILESZ = 5, /* phdr:p_filesz */ PHDR_CMD_T_P_MEMSZ = 6, /* phdr:p_memsz */ PHDR_CMD_T_P_FLAGS = 7, /* phdr:p_flags */ PHDR_CMD_T_P_ALIGN = 8, /* phdr:p_align */ /* Commands that do not correspond directly to a specific phdr tag */ PHDR_CMD_T_INTERP = 9, /* phdr:interp */ PHDR_CMD_T_DELETE = 10, /* phdr:delete */ PHDR_CMD_T_MOVE = 11 /* phdr:move */ } PHDR_CMD_T; /* * The following type is ued by locate_interp() to return * information about the interpreter program header. */ typedef struct { Word phndx; /* Index of PT_INTERP header */ Phdr *phdr; /* PT_INTERP header */ elfedit_section_t *sec; /* Section containing string */ Word stroff; /* Offset into string section */ const char *str; /* Interpreter string */ } INTERP_STATE; #ifndef _ELF64 /* * We supply this function for the msg module */ const char * _phdr_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 phdr_opt_t enum specifies a bit value for every optional * argument allowed by a command in this module. */ typedef enum { PHDR_OPT_F_AND = 1, /* -and: AND (&) values to dest */ PHDR_OPT_F_CMP = 2, /* -cmp: Complement (~) values */ PHDR_OPT_F_PHNDX = 4, /* -phndx: Program header by index, */ /* not by name */ PHDR_OPT_F_OR = 8 /* -or: OR (|) values to dest */ } phdr_opt_t; /* * A variable of type ARGSTATE is used by each command to maintain * information about the section headers and related things. It is * initialized by process_args(), and used by the other routines. */ typedef struct { elfedit_obj_state_t *obj_state; phdr_opt_t optmask; /* Mask of options used */ int argc; /* # of plain arguments */ const char **argv; /* Plain arguments */ int ndx_set; /* True if ndx is valid */ Word ndx; /* Index of header if cmd */ /* accepts it */ int print_req; /* Call is a print request */ } ARGSTATE; /* * Standard argument processing for phdr module * * entry * obj_state, argc, argv - Standard command arguments * optmask - Mask of allowed optional arguments. * cmd - PHDR_CMD_T_* value giving identify of caller * 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[], PHDR_CMD_T cmd, 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; /* Are the right number of plain arguments present? */ switch (cmd) { case PHDR_CMD_T_DUMP: if (argc > 1) elfedit_command_usage(); argstate->print_req = 1; break; case PHDR_CMD_T_P_FLAGS: /* phdr:sh_flags allows an arbitrary number of arguments */ argstate->print_req = (argc < 2); break; case PHDR_CMD_T_INTERP: if (argc > 1) elfedit_command_usage(); argstate->print_req = (argc == 0); break; case PHDR_CMD_T_DELETE: if ((argc < 1) || (argc > 2)) elfedit_command_usage(); argstate->print_req = 0; break; case PHDR_CMD_T_MOVE: if ((argc < 2) || (argc > 3)) elfedit_command_usage(); argstate->print_req = 0; break; default: /* The remaining commands accept 2 plain arguments */ if (argc > 2) elfedit_command_usage(); argstate->print_req = (argc < 2); break; } /* Return the updated values of argc/argv */ argstate->argc = argc; argstate->argv = argv; argstate->ndx_set = 0; if ((argc > 0) && (cmd != PHDR_CMD_T_INTERP)) { /* * If the -phndx option is present, the first argument is * the index of the header to use. Otherwise, it is a * name corresponding to its type, similar to the way * elfdump works with its -N option. */ if (argstate->optmask & PHDR_OPT_F_PHNDX) { argstate->ndx = (Word) elfedit_atoui_range( argstate->argv[0], MSG_ORIG(MSG_STR_ELEMENT), 0, argstate->obj_state->os_phnum - 1, NULL); argstate->ndx_set = 1; } else { Conv_inv_buf_t inv_buf; Ehdr *ehdr = obj_state->os_ehdr; Half mach = ehdr->e_machine; uchar_t osabi = ehdr->e_ident[EI_OSABI]; Word i; Phdr *phdr; argstate->ndx = (Word) elfedit_atoconst( argstate->argv[0], ELFEDIT_CONST_PT); phdr = obj_state->os_phdr; for (i = 0; i < obj_state->os_phnum; i++, phdr++) { if (phdr->p_type == argstate->ndx) { argstate->ndx = i; argstate->ndx_set = 1; elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_PHDR), EC_WORD(i), conv_phdr_type(osabi, mach, phdr->p_type, 0, &inv_buf)); break; } } if (i == argstate->obj_state->os_phnum) elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOPHDR), conv_phdr_type( osabi, mach, argstate->ndx, 0, &inv_buf)); } } /* If there may be an arbitrary amount of output, use a pager */ if (argc == 0) elfedit_pager_init(); } /* * Locate the interpreter string for the object and related information * * entry: * obj_state - Object state * interp - NULL, or variable to be filled in with information * about the interpteter string. */ static const char * locate_interp(elfedit_obj_state_t *obj_state, INTERP_STATE *interp) { INTERP_STATE local_interp; elfedit_section_t *strsec; /* String table */ size_t phnum; /* # of program headers */ int phndx; /* Index of PT_INTERP program header */ Phdr *phdr; /* Program header array */ Word i; if (interp == NULL) interp = &local_interp; /* Locate the PT_INTERP program header */ phnum = obj_state->os_phnum; phdr = obj_state->os_phdr; for (phndx = 0; phndx < phnum; phndx++) { if (phdr[phndx].p_type == PT_INTERP) { interp->phndx = phndx; interp->phdr = phdr + phndx; break; } } /* If no PT_INTERP program header found, we cannot proceed */ if (phndx == phnum) elfedit_elferr(obj_state->os_file, MSG_INTL(MSG_ERR_NOINTERPPHDR)); /* * Locate the section containing the interpteter string as well * as the string itself. * * The program header contains a direct offset to the string, so * we find the section by walking through the them looking for * the one with a base and size that would contain the string. * Note that this target section cannot be in a NOBITS section. */ for (i = 1; i < obj_state->os_shnum; i++) { strsec = &obj_state->os_secarr[i]; if ((strsec->sec_shdr->sh_type != SHT_NOBITS) && (interp->phdr->p_offset >= strsec->sec_shdr->sh_offset) && ((interp->phdr->p_offset + interp->phdr->p_filesz) <= (strsec->sec_shdr->sh_offset + strsec->sec_shdr->sh_size))) { interp->sec = strsec; interp->stroff = interp->phdr->p_offset - strsec->sec_shdr->sh_offset; interp->str = ((char *)strsec->sec_data->d_buf) + interp->stroff; return (interp->str); } } /* * We don't expect to get here: If there is a PT_INTERP header, * we fully expect the string to exist. */ elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOINTERPSEC)); /*NOTREACHED*/ return (NULL); /* For lint */ } /* * Print program header values, taking the calling command, and output style * into account. * * entry: * autoprint - If True, output is only produced if the elfedit * autoprint flag is set. If False, output is always produced. * cmd - PHDR_CMD_T_* value giving identify of caller * argstate - State block for section header array. The following * fields are examined in order to determine the form * of output: ndx_set, ndx, print_req. */ static void print_phdr(PHDR_CMD_T cmd, int autoprint, ARGSTATE *argstate) { elfedit_outstyle_t outstyle; Ehdr *ehdr = argstate->obj_state->os_ehdr; uchar_t osabi = ehdr->e_ident[EI_OSABI]; Half mach = ehdr->e_machine; Word ndx, cnt, by_type, type; Phdr *phdr; if (autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0)) return; /* * Determine which indexes to display: * * - If the user specified an index, the display starts * with that item. If it was a print_request, and the * index was specified by type, then all items of the * same type are shown. If not a print request, or the index * was given numerically, then just the single item is shown. * * - If no index is specified, every program header is shown. */ by_type = 0; if (argstate->ndx_set) { ndx = argstate->ndx; if (argstate->print_req && ((argstate->optmask & PHDR_OPT_F_PHNDX) == 0)) { by_type = 1; type = argstate->obj_state->os_phdr[ndx].p_type; cnt = argstate->obj_state->os_phnum - ndx; } else { cnt = 1; } } else { ndx = 0; cnt = argstate->obj_state->os_phnum; } phdr = argstate->obj_state->os_phdr + ndx; /* * Pick an output style. phdr:dump is required to use the default * style. The other commands use the current output style. */ outstyle = (cmd == PHDR_CMD_T_DUMP) ? ELFEDIT_OUTSTYLE_DEFAULT : elfedit_outstyle(); /* * If doing default output, use elfdump style where we * show all program header attributes. In this case, the * command that called us doesn't matter. * * Exclude PHDR_CMD_T_INTERP from this: It isn't per-phdr like * the other commands. */ if ((outstyle == ELFEDIT_OUTSTYLE_DEFAULT) && (cmd != PHDR_CMD_T_INTERP)) { for (; cnt--; ndx++, phdr++) { if (by_type && (type != phdr->p_type)) continue; elfedit_printf(MSG_ORIG(MSG_STR_NL)); elfedit_printf(MSG_INTL(MSG_ELF_PHDR), EC_WORD(ndx)); Elf_phdr(0, osabi, mach, phdr); } return; } if (cmd == PHDR_CMD_T_INTERP) { INTERP_STATE interp; (void) locate_interp(argstate->obj_state, &interp); switch (outstyle) { case ELFEDIT_OUTSTYLE_DEFAULT: elfedit_printf(MSG_INTL(MSG_FMT_ELF_INTERP), interp.sec->sec_name, interp.str); break; case ELFEDIT_OUTSTYLE_SIMPLE: elfedit_printf(MSG_ORIG(MSG_FMT_STRNL), interp.str); break; case ELFEDIT_OUTSTYLE_NUM: elfedit_printf(MSG_ORIG(MSG_FMT_U_NL), EC_WORD(interp.stroff)); break; } return; } /* Handle the remaining commands */ for (; cnt--; ndx++, phdr++) { if (by_type && (type != phdr->p_type)) continue; switch (cmd) { case PHDR_CMD_T_P_TYPE: if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) { Conv_inv_buf_t inv_buf; elfedit_printf(MSG_ORIG(MSG_FMT_STRNL), conv_phdr_type(osabi, argstate->obj_state->os_ehdr->e_machine, phdr->p_type, 0, &inv_buf)); } else { elfedit_printf(MSG_ORIG(MSG_FMT_X_NL), EC_WORD(phdr->p_type)); } break; case PHDR_CMD_T_P_OFFSET: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_OFF(phdr->p_offset)); break; case PHDR_CMD_T_P_VADDR: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_ADDR(phdr->p_vaddr)); break; case PHDR_CMD_T_P_PADDR: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_ADDR(phdr->p_paddr)); break; case PHDR_CMD_T_P_FILESZ: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_XWORD(phdr->p_filesz)); break; case PHDR_CMD_T_P_MEMSZ: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_XWORD(phdr->p_memsz)); break; case PHDR_CMD_T_P_FLAGS: if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) { Conv_phdr_flags_buf_t phdr_flags_buf; elfedit_printf(MSG_ORIG(MSG_FMT_STRNL), conv_phdr_flags(osabi, phdr->p_flags, CONV_FMT_NOBKT, &phdr_flags_buf)); } else { elfedit_printf(MSG_ORIG(MSG_FMT_X_NL), EC_WORD(phdr->p_flags)); } break; case PHDR_CMD_T_P_ALIGN: elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL), EC_XWORD(phdr->p_align)); break; } } } /* * Called from cmd_body() in the case where a plain argument * is given to phdr:interp to change the interpreter. */ static elfedit_cmdret_t cmd_body_set_interp(ARGSTATE *argstate) { elfedit_obj_state_t *obj_state = argstate->obj_state; elfedit_section_t *strsec; /* String table */ INTERP_STATE interp; Word numdyn; /* # of elements in dyn arr */ size_t phnum; /* # of program headers */ Phdr *phdr; /* Program header array */ Word i, j; Word str_offset; /* Offset in strsec to new interp str */ int str_found = 0; /* True when we have new interp str */ Word str_size; /* Size of new interp string + NULL */ phnum = obj_state->os_phnum; phdr = obj_state->os_phdr; /* Locate the PT_INTERP program header */ (void) locate_interp(obj_state, &interp); strsec = interp.sec; str_offset = interp.stroff; /* * If the given string is the same as the existing interpreter * string, say so and return. */ if (strcmp(interp.str, argstate->argv[0]) == 0) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_OLDINTERPOK), EC_WORD(strsec->sec_shndx), strsec->sec_name, EC_WORD(str_offset), interp.str); return (ELFEDIT_CMDRET_NONE); } /* * An ELF PT_INTERP usually references its own special section * instead of some other string table. The ELF ABI says that this * section must be named ".interp". Hence, this is a rare case * in which the name of a section can be taken as an indication * of its contents. .interp is typically sized to just fit * the original string, including its NULL termination. You can * treat it as a string table with one string. * * Thanks to 'elfedit', it may be that we encounter a file where * PT_INTERP does not reference the .interp section. This will happen * if elfedit is used to change the interpreter to a string that is * too big to fit in .interp, in which case we will use the * .dynstr string table (That code is below, in this function). * * Given the above facts, our next step is to locate the .interp * section and see if our new string will fit in it. Since we can't * depend on PT_INTERP, we search the section headers to find a * section whith the following characteristics: * - The name is ".interp". * - Section is allocable (SHF_ALLOC) and SHT_PROGBITS. * - It is not part of a writable segment. * If we find such a section, and the new string fits, we will * write it there. */ str_size = strlen(argstate->argv[0]) + 1; for (i = 1; i < obj_state->os_shnum; i++) { strsec = &obj_state->os_secarr[i]; if ((strcmp(strsec->sec_name, MSG_ORIG(MSG_SEC_INTERP)) == 0) && (strsec->sec_shdr->sh_flags & SHF_ALLOC) && (strsec->sec_shdr->sh_type & SHT_PROGBITS)) { for (j = 0; j < phnum; j++) { Phdr *tphdr = &phdr[j]; if ((strsec->sec_shdr->sh_offset >= tphdr->p_offset) && ((strsec->sec_shdr->sh_offset + strsec->sec_shdr->sh_size) <= (tphdr->p_offset + tphdr->p_filesz)) && (tphdr->p_flags & PF_W)) { break; } } if ((j == phnum) && (str_size <= strsec->sec_shdr->sh_size)) { /* .interp section found, and has room */ str_found = 1; str_offset = 0; elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_NEWISTR), EC_WORD(j), strsec->sec_name, EC_WORD(str_offset), argstate->argv[0]); /* Put new value in section */ (void) strncpy((char *)strsec->sec_data->d_buf, argstate->argv[0], strsec->sec_shdr->sh_size); /* Set libelf dirty bit so change is flushed */ elfedit_modified_data(strsec); break; } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LNGISTR), EC_WORD(j), strsec->sec_name, EC_WORD(str_offset), EC_WORD(str_size), EC_WORD(strsec->sec_shdr->sh_size), argstate->argv[0]); } } } /* * If the above did not find a string within the .interp section, * then we have a second option. If this ELF object has a dynamic * section, then we are willing to use strings from within the * associated .dynstr string table. And if there is reserved space * in .dynstr (as reported by the DT_SUNW_STRPAD dynamic entry), * then we are even willing to add a new string to .dynstr. */ if (!str_found) { elfedit_section_t *dynsec; Dyn *dyn; dynsec = elfedit_sec_getdyn(obj_state, &dyn, &numdyn); strsec = elfedit_sec_getstr(obj_state, dynsec->sec_shdr->sh_link, 0); /* Does string exist in the table already, or can we add it? */ str_offset = elfedit_strtab_insert(obj_state, strsec, dynsec, argstate->argv[0]); } /* * If we are here, we know we have a replacement string, because * the errors from checking .dynamic/.dynstr will not allow * things to get here otherwise. * * The PT_INTERP program header references the string directly, * so we add the section offset to the string offset. */ interp.phdr->p_offset = strsec->sec_shdr->sh_offset + str_offset; interp.phdr->p_filesz = str_size; elfedit_modified_phdr(obj_state); elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_SETPHINTERP), EC_WORD(interp.phndx), EC_XWORD(interp.phdr->p_offset), EC_XWORD(interp.phdr->p_filesz)); return (ELFEDIT_CMDRET_MOD); } /* * Common body for the phdr: 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 PHDR_CMD_T_* constants listed above, specifying * which command to implement. * obj_state, argc, argv - Standard command arguments */ static elfedit_cmdret_t cmd_body(PHDR_CMD_T cmd, elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { ARGSTATE argstate; Phdr *phdr; elfedit_cmdret_t ret = ELFEDIT_CMDRET_NONE; int do_autoprint = 1; process_args(obj_state, argc, argv, cmd, &argstate); /* If this is a printing request, print and return */ if (argstate.print_req) { print_phdr(cmd, 0, &argstate); return (ELFEDIT_CMDRET_NONE); } if (argstate.ndx_set) phdr = &argstate.obj_state->os_phdr[argstate.ndx]; switch (cmd) { /* * PHDR_CMD_T_DUMP can't get here: It never has more than * one argument, and is handled above. */ case PHDR_CMD_T_P_TYPE: { Ehdr *ehdr = obj_state->os_ehdr; uchar_t osabi = ehdr->e_ident[EI_OSABI]; Half mach = ehdr->e_machine; Word p_type = elfedit_atoconst(argstate.argv[1], ELFEDIT_CONST_PT); Conv_inv_buf_t inv_buf1, inv_buf2; if (phdr->p_type == p_type) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_TYPE), conv_phdr_type(osabi, mach, phdr->p_type, 0, &inv_buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_TYPE), conv_phdr_type(osabi, mach, phdr->p_type, 0, &inv_buf1), conv_phdr_type(osabi, mach, p_type, 0, &inv_buf2)); ret = ELFEDIT_CMDRET_MOD; phdr->p_type = p_type; } } break; case PHDR_CMD_T_P_OFFSET: { Off p_offset; p_offset = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_offset == p_offset) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_OFFSET), EC_XWORD(phdr->p_offset)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_OFFSET), EC_XWORD(phdr->p_offset), EC_XWORD(p_offset)); ret = ELFEDIT_CMDRET_MOD; phdr->p_offset = p_offset; } } break; case PHDR_CMD_T_P_VADDR: { Addr p_vaddr = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_vaddr == p_vaddr) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_VADDR), EC_ADDR(phdr->p_vaddr)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_VADDR), EC_ADDR(phdr->p_vaddr), EC_ADDR(p_vaddr)); ret = ELFEDIT_CMDRET_MOD; phdr->p_vaddr = p_vaddr; } } break; case PHDR_CMD_T_P_PADDR: { Addr p_paddr = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_paddr == p_paddr) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_PADDR), EC_ADDR(phdr->p_paddr)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_PADDR), EC_ADDR(phdr->p_paddr), EC_ADDR(p_paddr)); ret = ELFEDIT_CMDRET_MOD; phdr->p_paddr = p_paddr; } } break; case PHDR_CMD_T_P_FILESZ: { Xword p_filesz = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_filesz == p_filesz) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_FILESZ), EC_XWORD(phdr->p_filesz)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_FILESZ), EC_XWORD(phdr->p_filesz), EC_XWORD(p_filesz)); ret = ELFEDIT_CMDRET_MOD; phdr->p_filesz = p_filesz; } } break; case PHDR_CMD_T_P_MEMSZ: { Xword p_memsz = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_memsz == p_memsz) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_MEMSZ), EC_XWORD(phdr->p_memsz)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_MEMSZ), EC_XWORD(phdr->p_memsz), EC_XWORD(p_memsz)); ret = ELFEDIT_CMDRET_MOD; phdr->p_memsz = p_memsz; } } break; case PHDR_CMD_T_P_FLAGS: { Ehdr *ehdr = obj_state->os_ehdr; uchar_t osabi = ehdr->e_ident[EI_OSABI]; Conv_phdr_flags_buf_t buf1, buf2; Word p_flags = 0; int i; /* Collect the flag arguments */ for (i = 1; i < argstate.argc; i++) p_flags |= (Word) elfedit_atoconst(argstate.argv[i], ELFEDIT_CONST_PF); /* Complement the value? */ if (argstate.optmask & PHDR_OPT_F_CMP) p_flags = ~p_flags; /* Perform any requested bit operations */ if (argstate.optmask & PHDR_OPT_F_AND) p_flags &= phdr->p_flags; else if (argstate.optmask & PHDR_OPT_F_OR) p_flags |= phdr->p_flags; /* Set the value */ if (phdr->p_flags == p_flags) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_FLAGS), conv_phdr_flags(osabi, phdr->p_flags, 0, &buf1)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_S_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_FLAGS), conv_phdr_flags(osabi, phdr->p_flags, 0, &buf1), conv_phdr_flags(osabi, p_flags, 0, &buf2)); ret = ELFEDIT_CMDRET_MOD; phdr->p_flags = p_flags; } } break; case PHDR_CMD_T_P_ALIGN: { Xword p_align = elfedit_atoui(argstate.argv[1], NULL); if (phdr->p_align == p_align) { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_OK), argstate.ndx, MSG_ORIG(MSG_CMD_P_ALIGN), EC_XWORD(phdr->p_align)); } else { elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_LLX_CHG), argstate.ndx, MSG_ORIG(MSG_CMD_P_ALIGN), EC_XWORD(phdr->p_align), EC_XWORD(p_align)); ret = ELFEDIT_CMDRET_MOD; phdr->p_align = p_align; } } break; case PHDR_CMD_T_INTERP: ret = cmd_body_set_interp(&argstate); break; case PHDR_CMD_T_DELETE: { Word cnt = (argstate.argc == 1) ? 1 : (Word) elfedit_atoui_range(argstate.argv[1], MSG_ORIG(MSG_STR_COUNT), 1, obj_state->os_phnum - argstate.ndx, NULL); elfedit_array_elts_delete(MSG_ORIG(MSG_MOD_NAME), obj_state->os_phdr, sizeof (Phdr), obj_state->os_phnum, argstate.ndx, cnt); do_autoprint = 0; ret = ELFEDIT_CMDRET_MOD; } break; case PHDR_CMD_T_MOVE: { Phdr save; Word cnt; Word dstndx; do_autoprint = 0; dstndx = (Word) elfedit_atoui_range(argstate.argv[1], MSG_ORIG(MSG_STR_DST_INDEX), 0, obj_state->os_phnum - 1, NULL); if (argstate.argc == 2) { cnt = 1; } else { cnt = (Word) elfedit_atoui_range( argstate.argv[2], MSG_ORIG(MSG_STR_COUNT), 1, obj_state->os_phnum, NULL); } elfedit_array_elts_move(MSG_ORIG(MSG_MOD_NAME), obj_state->os_phdr, sizeof (save), obj_state->os_phnum, argstate.ndx, dstndx, cnt, &save); ret = ELFEDIT_CMDRET_MOD; } break; } /* * If we modified the section header array, tell libelf. */ if (ret == ELFEDIT_CMDRET_MOD) elfedit_modified_phdr(obj_state); /* Do autoprint */ if (do_autoprint) print_phdr(cmd, 1, &argstate); return (ret); } /* * Command completion functions for the various commands */ /* * A number of the commands accept a PT_ constant as their first * argument as long as the -phndx option is not used. */ /*ARGSUSED*/ static void cpl_1starg_pt(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { int i; for (i = 0; i < num_opt; i++) if (strcmp(MSG_ORIG(MSG_STR_MINUS_PHNDX), argv[i]) == 0) return; if (argc == (num_opt + 1)) elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PT); } /*ARGSUSED*/ static void cpl_p_type(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* The first argument follows the standard rules */ cpl_1starg_pt(obj_state, cpldata, argc, argv, num_opt); /* The second argument can be a PT_ value */ if (argc == (num_opt + 2)) elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PT); } /*ARGSUSED*/ static void cpl_p_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc, const char *argv[], int num_opt) { /* The first argument follows the standard rules */ cpl_1starg_pt(obj_state, cpldata, argc, argv, num_opt); /* The second and following arguments can be an PF_ value */ if (argc >= (num_opt + 2)) elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PF); } /* * 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(PHDR_CMD_T_DUMP, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_type(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_TYPE, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_offset(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_OFFSET, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_vaddr(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_VADDR, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_paddr(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_PADDR, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_filesz(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_FILESZ, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_memsz(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_MEMSZ, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_flags(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_FLAGS, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_p_align(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_P_ALIGN, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_interp(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_CMD_T_INTERP, obj_state, argc, argv)); } static elfedit_cmdret_t cmd_delete(elfedit_obj_state_t *obj_state, int argc, const char *argv[]) { return (cmd_body(PHDR_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(PHDR_CMD_T_MOVE, obj_state, argc, argv)); } /*ARGSUSED*/ elfedit_module_t * elfedit_init(elfedit_module_version_t version) { /* Multiple commands accept a standard set of options */ static elfedit_cmd_optarg_t opt_std[] = { { ELFEDIT_STDOA_OPT_O, 0, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { MSG_ORIG(MSG_STR_MINUS_PHNDX), /* MSG_INTL(MSG_OPTDESC_PHNDX) */ ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0, PHDR_OPT_F_PHNDX, 0 }, { NULL } }; /* For commands that only accept -phndx */ static elfedit_cmd_optarg_t opt_minus_phndx[] = { { MSG_ORIG(MSG_STR_MINUS_PHNDX), /* MSG_INTL(MSG_OPTDESC_PHNDX) */ ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0, PHDR_OPT_F_PHNDX, 0 }, { NULL } }; /* phdr: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_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_type */ static const char *name_p_type[] = { MSG_ORIG(MSG_CMD_P_TYPE), NULL }; static elfedit_cmd_optarg_t arg_p_type[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_TYPE), /* MSG_INTL(MSG_A2_P_TYPE_TYPE) */ ELFEDIT_I18NHDL(MSG_A2_P_TYPE_TYPE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_offset */ static const char *name_p_offset[] = { MSG_ORIG(MSG_CMD_P_OFFSET), NULL }; static elfedit_cmd_optarg_t arg_p_offset[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A2_P_OFFSET_VALUE) */ ELFEDIT_I18NHDL(MSG_A2_P_OFFSET_VALUE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_vaddr */ static const char *name_p_vaddr[] = { MSG_ORIG(MSG_CMD_P_VADDR), NULL }; static elfedit_cmd_optarg_t arg_p_vaddr[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_ADDR), /* MSG_INTL(MSG_A2_P_VADDR_ADDR) */ ELFEDIT_I18NHDL(MSG_A2_P_VADDR_ADDR), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_paddr */ static const char *name_p_paddr[] = { MSG_ORIG(MSG_CMD_P_PADDR), NULL }; static elfedit_cmd_optarg_t arg_p_paddr[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_ADDR), /* MSG_INTL(MSG_A2_P_PADDR_ADDR) */ ELFEDIT_I18NHDL(MSG_A2_P_PADDR_ADDR), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_filesz */ static const char *name_p_filesz[] = { MSG_ORIG(MSG_CMD_P_FILESZ), NULL }; static elfedit_cmd_optarg_t arg_p_filesz[] = { /* MSG_INTL(MSG_A1_ELEMENT) */ { MSG_ORIG(MSG_STR_ELEMENT), ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_SIZE), /* MSG_INTL(MSG_A2_P_FILESZ_SIZE) */ ELFEDIT_I18NHDL(MSG_A2_P_FILESZ_SIZE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:p_memsz */ static const char *name_p_memsz[] = { MSG_ORIG(MSG_CMD_P_MEMSZ), NULL }; static elfedit_cmd_optarg_t arg_p_memsz[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_SIZE), /* MSG_INTL(MSG_A2_P_MEMSZ_SIZE) */ ELFEDIT_I18NHDL(MSG_A2_P_MEMSZ_SIZE), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* shdr:p_flags */ static const char *name_p_flags[] = { MSG_ORIG(MSG_CMD_P_FLAGS), NULL }; static elfedit_cmd_optarg_t opt_p_flags[] = { { ELFEDIT_STDOA_OPT_AND, 0, ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_AND, PHDR_OPT_F_OR }, { ELFEDIT_STDOA_OPT_CMP, 0, ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_CMP, 0 }, { MSG_ORIG(MSG_STR_MINUS_PHNDX), /* MSG_INTL(MSG_OPTDESC_PHNDX) */ ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0, PHDR_OPT_F_PHNDX, 0 }, { ELFEDIT_STDOA_OPT_O, 0, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { ELFEDIT_STDOA_OPT_OR, 0, ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_OR, PHDR_OPT_F_AND }, { NULL } }; static elfedit_cmd_optarg_t arg_p_flags[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_VALUE), /* MSG_INTL(MSG_A2_P_FLAGS_VALUE) */ ELFEDIT_I18NHDL(MSG_A2_P_FLAGS_VALUE), ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT }, { NULL } }; /* phdr:p_align */ static const char *name_p_align[] = { MSG_ORIG(MSG_CMD_P_ALIGN), NULL }; static elfedit_cmd_optarg_t arg_p_align[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { MSG_ORIG(MSG_STR_ALIGN), /* MSG_INTL(MSG_A2_P_ALIGN_ALIGN) */ ELFEDIT_I18NHDL(MSG_A2_P_ALIGN_ALIGN), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:interp */ static const char *name_interp[] = { MSG_ORIG(MSG_CMD_INTERP), NULL }; static elfedit_cmd_optarg_t opt_interp[] = { { ELFEDIT_STDOA_OPT_O, 0, ELFEDIT_CMDOA_F_INHERIT, 0, 0 }, { NULL } }; static elfedit_cmd_optarg_t arg_interp[] = { { MSG_ORIG(MSG_STR_NEWPATH), /* MSG_INTL(MSG_A1_INTERP_NEWPATH) */ ELFEDIT_I18NHDL(MSG_A1_INTERP_NEWPATH), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:delete */ static const char *name_delete[] = { MSG_ORIG(MSG_CMD_DELETE), NULL }; static elfedit_cmd_optarg_t arg_delete[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), 0 }, { MSG_ORIG(MSG_STR_COUNT), /* MSG_INTL(MSG_A2_DELETE_COUNT) */ ELFEDIT_I18NHDL(MSG_A2_DELETE_COUNT), ELFEDIT_CMDOA_F_OPT }, { NULL } }; /* phdr:move */ static const char *name_move[] = { MSG_ORIG(MSG_CMD_MOVE), NULL }; static elfedit_cmd_optarg_t arg_move[] = { { MSG_ORIG(MSG_STR_ELEMENT), /* MSG_INTL(MSG_A1_ELEMENT) */ ELFEDIT_I18NHDL(MSG_A1_ELEMENT), ELFEDIT_CMDOA_F_OPT }, { 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 } }; static elfedit_cmd_t cmds[] = { /* phdr:dump */ { cmd_dump, cpl_1starg_pt, name_dump, /* MSG_INTL(MSG_DESC_DUMP) */ ELFEDIT_I18NHDL(MSG_DESC_DUMP), /* MSG_INTL(MSG_HELP_DUMP) */ ELFEDIT_I18NHDL(MSG_HELP_DUMP), opt_minus_phndx, arg_dump }, /* phdr:p_type */ { cmd_p_type, cpl_p_type, name_p_type, /* MSG_INTL(MSG_DESC_P_TYPE) */ ELFEDIT_I18NHDL(MSG_DESC_P_TYPE), /* MSG_INTL(MSG_HELP_P_TYPE) */ ELFEDIT_I18NHDL(MSG_HELP_P_TYPE), opt_std, arg_p_type }, /* phdr:p_offset */ { cmd_p_offset, cpl_1starg_pt, name_p_offset, /* MSG_INTL(MSG_DESC_P_OFFSET) */ ELFEDIT_I18NHDL(MSG_DESC_P_OFFSET), /* MSG_INTL(MSG_HELP_P_OFFSET) */ ELFEDIT_I18NHDL(MSG_HELP_P_OFFSET), opt_std, arg_p_offset }, /* phdr:p_vaddr */ { cmd_p_vaddr, cpl_1starg_pt, name_p_vaddr, /* MSG_INTL(MSG_DESC_P_VADDR) */ ELFEDIT_I18NHDL(MSG_DESC_P_VADDR), /* MSG_INTL(MSG_HELP_P_VADDR) */ ELFEDIT_I18NHDL(MSG_HELP_P_VADDR), opt_std, arg_p_vaddr }, /* phdr:p_paddr */ { cmd_p_paddr, cpl_1starg_pt, name_p_paddr, /* MSG_INTL(MSG_DESC_P_PADDR) */ ELFEDIT_I18NHDL(MSG_DESC_P_PADDR), /* MSG_INTL(MSG_HELP_P_PADDR) */ ELFEDIT_I18NHDL(MSG_HELP_P_PADDR), opt_std, arg_p_paddr }, /* phdr:p_filesz */ { cmd_p_filesz, cpl_1starg_pt, name_p_filesz, /* MSG_INTL(MSG_DESC_P_FILESZ) */ ELFEDIT_I18NHDL(MSG_DESC_P_FILESZ), /* MSG_INTL(MSG_HELP_P_FILESZ) */ ELFEDIT_I18NHDL(MSG_HELP_P_FILESZ), opt_std, arg_p_filesz }, /* phdr:p_memsz */ { cmd_p_memsz, cpl_1starg_pt, name_p_memsz, /* MSG_INTL(MSG_DESC_P_MEMSZ) */ ELFEDIT_I18NHDL(MSG_DESC_P_MEMSZ), /* MSG_INTL(MSG_HELP_P_MEMSZ) */ ELFEDIT_I18NHDL(MSG_HELP_P_MEMSZ), opt_std, arg_p_memsz }, /* phdr:p_flags */ { cmd_p_flags, cpl_p_flags, name_p_flags, /* MSG_INTL(MSG_DESC_P_FLAGS) */ ELFEDIT_I18NHDL(MSG_DESC_P_FLAGS), /* MSG_INTL(MSG_HELP_P_FLAGS) */ ELFEDIT_I18NHDL(MSG_HELP_P_FLAGS), opt_p_flags, arg_p_flags }, /* phdr:p_align */ { cmd_p_align, cpl_1starg_pt, name_p_align, /* MSG_INTL(MSG_DESC_P_ALIGN) */ ELFEDIT_I18NHDL(MSG_DESC_P_ALIGN), /* MSG_INTL(MSG_HELP_P_ALIGN) */ ELFEDIT_I18NHDL(MSG_HELP_P_ALIGN), opt_std, arg_p_align }, /* phdr:interp */ { cmd_interp, NULL, name_interp, /* MSG_INTL(MSG_DESC_INTERP) */ ELFEDIT_I18NHDL(MSG_DESC_INTERP), /* MSG_INTL(MSG_HELP_INTERP) */ ELFEDIT_I18NHDL(MSG_HELP_INTERP), opt_interp, arg_interp }, /* phdr:delete */ { cmd_delete, cpl_1starg_pt, name_delete, /* MSG_INTL(MSG_DESC_DELETE) */ ELFEDIT_I18NHDL(MSG_DESC_DELETE), /* MSG_INTL(MSG_HELP_DELETE) */ ELFEDIT_I18NHDL(MSG_HELP_DELETE), opt_minus_phndx, arg_delete }, /* phdr:move */ { cmd_move, cpl_1starg_pt, name_move, /* MSG_INTL(MSG_DESC_MOVE) */ ELFEDIT_I18NHDL(MSG_DESC_MOVE), /* MSG_INTL(MSG_HELP_MOVE) */ ELFEDIT_I18NHDL(MSG_HELP_MOVE), opt_minus_phndx, arg_move }, { 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); }