1 /*- 2 * Copyright (c) 2007-2011,2014 Kai Wang 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/param.h> 28 #include <sys/stat.h> 29 #include <err.h> 30 #include <libgen.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 35 #include "elfcopy.h" 36 37 ELFTC_VCSID("$Id: sections.c 3646 2018-10-27 02:25:39Z emaste $"); 38 39 static void add_gnu_debuglink(struct elfcopy *ecp); 40 static uint32_t calc_crc32(const char *p, size_t len, uint32_t crc); 41 static void check_section_rename(struct elfcopy *ecp, struct section *s); 42 static void filter_reloc(struct elfcopy *ecp, struct section *s); 43 static int get_section_flags(struct elfcopy *ecp, const char *name); 44 static void insert_sections(struct elfcopy *ecp); 45 static void insert_to_strtab(struct section *t, const char *s); 46 static int is_append_section(struct elfcopy *ecp, const char *name); 47 static int is_compress_section(struct elfcopy *ecp, const char *name); 48 static int is_debug_section(const char *name); 49 static int is_dwo_section(const char *name); 50 static int is_modify_section(struct elfcopy *ecp, const char *name); 51 static int is_print_section(struct elfcopy *ecp, const char *name); 52 static int lookup_string(struct section *t, const char *s); 53 static void modify_section(struct elfcopy *ecp, struct section *s); 54 static void pad_section(struct elfcopy *ecp, struct section *s); 55 static void print_data(const char *d, size_t sz); 56 static void print_section(struct section *s); 57 static void *read_section(struct section *s, size_t *size); 58 static void update_reloc(struct elfcopy *ecp, struct section *s); 59 static void update_section_group(struct elfcopy *ecp, struct section *s); 60 61 int 62 is_remove_section(struct elfcopy *ecp, const char *name) 63 { 64 65 /* Always keep section name table */ 66 if (strcmp(name, ".shstrtab") == 0) 67 return 0; 68 if (strcmp(name, ".symtab") == 0 || 69 strcmp(name, ".strtab") == 0) { 70 if (ecp->strip == STRIP_ALL && lookup_symop_list( 71 ecp, NULL, SYMOP_KEEP) == NULL) 72 return (1); 73 else 74 return (0); 75 } 76 77 if (ecp->strip == STRIP_DWO && is_dwo_section(name)) 78 return (1); 79 if (ecp->strip == STRIP_NONDWO && !is_dwo_section(name)) 80 return (1); 81 82 if (is_debug_section(name)) { 83 if (ecp->strip == STRIP_ALL || 84 ecp->strip == STRIP_DEBUG || 85 ecp->strip == STRIP_UNNEEDED || 86 (ecp->flags & DISCARD_LOCAL)) 87 return (1); 88 if (ecp->strip == STRIP_NONDEBUG) 89 return (0); 90 } 91 92 if ((ecp->flags & SEC_REMOVE) || (ecp->flags & SEC_COPY)) { 93 struct sec_action *sac; 94 95 sac = lookup_sec_act(ecp, name, 0); 96 if ((ecp->flags & SEC_REMOVE) && sac != NULL && sac->remove) 97 return (1); 98 if ((ecp->flags & SEC_COPY) && (sac == NULL || !sac->copy)) 99 return (1); 100 } 101 102 return (0); 103 } 104 105 /* 106 * Relocation section needs to be removed if the section it applies to 107 * will be removed. 108 */ 109 int 110 is_remove_reloc_sec(struct elfcopy *ecp, uint32_t sh_info) 111 { 112 const char *name; 113 GElf_Shdr ish; 114 Elf_Scn *is; 115 size_t indx; 116 int elferr; 117 118 if (elf_getshstrndx(ecp->ein, &indx) == 0) 119 errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", 120 elf_errmsg(-1)); 121 122 is = NULL; 123 while ((is = elf_nextscn(ecp->ein, is)) != NULL) { 124 if (sh_info == elf_ndxscn(is)) { 125 if (gelf_getshdr(is, &ish) == NULL) 126 errx(EXIT_FAILURE, "gelf_getshdr failed: %s", 127 elf_errmsg(-1)); 128 if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) == 129 NULL) 130 errx(EXIT_FAILURE, "elf_strptr failed: %s", 131 elf_errmsg(-1)); 132 if (is_remove_section(ecp, name)) 133 return (1); 134 else 135 return (0); 136 } 137 } 138 elferr = elf_errno(); 139 if (elferr != 0) 140 errx(EXIT_FAILURE, "elf_nextscn failed: %s", 141 elf_errmsg(elferr)); 142 143 /* Remove reloc section if we can't find the target section. */ 144 return (1); 145 } 146 147 static int 148 is_append_section(struct elfcopy *ecp, const char *name) 149 { 150 struct sec_action *sac; 151 152 sac = lookup_sec_act(ecp, name, 0); 153 if (sac != NULL && sac->append != 0 && sac->string != NULL) 154 return (1); 155 156 return (0); 157 } 158 159 static int 160 is_compress_section(struct elfcopy *ecp, const char *name) 161 { 162 struct sec_action *sac; 163 164 sac = lookup_sec_act(ecp, name, 0); 165 if (sac != NULL && sac->compress != 0) 166 return (1); 167 168 return (0); 169 } 170 171 static void 172 check_section_rename(struct elfcopy *ecp, struct section *s) 173 { 174 struct sec_action *sac; 175 char *prefix; 176 size_t namelen; 177 178 if (s->pseudo) 179 return; 180 181 sac = lookup_sec_act(ecp, s->name, 0); 182 if (sac != NULL && sac->rename) 183 s->name = sac->newname; 184 185 if (!strcmp(s->name, ".symtab") || 186 !strcmp(s->name, ".strtab") || 187 !strcmp(s->name, ".shstrtab")) 188 return; 189 190 prefix = NULL; 191 if (s->loadable && ecp->prefix_alloc != NULL) 192 prefix = ecp->prefix_alloc; 193 else if (ecp->prefix_sec != NULL) 194 prefix = ecp->prefix_sec; 195 196 if (prefix != NULL) { 197 namelen = strlen(s->name) + strlen(prefix) + 1; 198 if ((s->newname = malloc(namelen)) == NULL) 199 err(EXIT_FAILURE, "malloc failed"); 200 snprintf(s->newname, namelen, "%s%s", prefix, s->name); 201 s->name = s->newname; 202 } 203 } 204 205 static int 206 get_section_flags(struct elfcopy *ecp, const char *name) 207 { 208 struct sec_action *sac; 209 210 sac = lookup_sec_act(ecp, name, 0); 211 if (sac != NULL && sac->flags) 212 return sac->flags; 213 214 return (0); 215 } 216 217 /* 218 * Determine whether the section are debugging section. 219 * According to libbfd, debugging sections are recognized 220 * only by name. 221 */ 222 static int 223 is_debug_section(const char *name) 224 { 225 const char *dbg_sec[] = { 226 ".apple_", 227 ".debug", 228 ".gnu.linkonce.wi.", 229 ".line", 230 ".stab", 231 NULL 232 }; 233 const char **p; 234 235 for(p = dbg_sec; *p; p++) { 236 if (strncmp(name, *p, strlen(*p)) == 0) 237 return (1); 238 } 239 240 return (0); 241 } 242 243 static int 244 is_dwo_section(const char *name) 245 { 246 size_t len; 247 248 if ((len = strlen(name)) > 4 && strcmp(name + len - 4, ".dwo") == 0) 249 return (1); 250 return (0); 251 } 252 253 static int 254 is_print_section(struct elfcopy *ecp, const char *name) 255 { 256 struct sec_action *sac; 257 258 sac = lookup_sec_act(ecp, name, 0); 259 if (sac != NULL && sac->print != 0) 260 return (1); 261 262 return (0); 263 } 264 265 static int 266 is_modify_section(struct elfcopy *ecp, const char *name) 267 { 268 269 if (is_append_section(ecp, name) || 270 is_compress_section(ecp, name)) 271 return (1); 272 273 return (0); 274 } 275 276 struct sec_action* 277 lookup_sec_act(struct elfcopy *ecp, const char *name, int add) 278 { 279 struct sec_action *sac; 280 281 if (name == NULL) 282 return NULL; 283 284 STAILQ_FOREACH(sac, &ecp->v_sac, sac_list) { 285 if (strcmp(name, sac->name) == 0) 286 return sac; 287 } 288 289 if (add == 0) 290 return NULL; 291 292 if ((sac = malloc(sizeof(*sac))) == NULL) 293 errx(EXIT_FAILURE, "not enough memory"); 294 memset(sac, 0, sizeof(*sac)); 295 sac->name = name; 296 STAILQ_INSERT_TAIL(&ecp->v_sac, sac, sac_list); 297 298 return (sac); 299 } 300 301 void 302 free_sec_act(struct elfcopy *ecp) 303 { 304 struct sec_action *sac, *sac_temp; 305 306 STAILQ_FOREACH_SAFE(sac, &ecp->v_sac, sac_list, sac_temp) { 307 STAILQ_REMOVE(&ecp->v_sac, sac, sec_action, sac_list); 308 free(sac); 309 } 310 } 311 312 void 313 insert_to_sec_list(struct elfcopy *ecp, struct section *sec, int tail) 314 { 315 struct section *s; 316 317 if (!tail) { 318 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 319 if (sec->off < s->off) { 320 TAILQ_INSERT_BEFORE(s, sec, sec_list); 321 goto inc_nos; 322 } 323 } 324 } 325 326 TAILQ_INSERT_TAIL(&ecp->v_sec, sec, sec_list); 327 328 inc_nos: 329 if (sec->pseudo == 0) 330 ecp->nos++; 331 } 332 333 /* 334 * First step of section creation: create scn and internal section 335 * structure, discard sections to be removed. 336 */ 337 void 338 create_scn(struct elfcopy *ecp) 339 { 340 struct section *s; 341 const char *name; 342 Elf_Scn *is; 343 GElf_Shdr ish; 344 size_t indx; 345 uint64_t oldndx, newndx; 346 int elferr, sec_flags, reorder; 347 348 /* 349 * Insert a pseudo section that contains the ELF header 350 * and program header. Used as reference for section offset 351 * or load address adjustment. 352 */ 353 if ((s = calloc(1, sizeof(*s))) == NULL) 354 err(EXIT_FAILURE, "calloc failed"); 355 s->off = 0; 356 s->sz = gelf_fsize(ecp->eout, ELF_T_EHDR, 1, EV_CURRENT) + 357 gelf_fsize(ecp->eout, ELF_T_PHDR, ecp->ophnum, EV_CURRENT); 358 s->align = 1; 359 s->pseudo = 1; 360 s->loadable = add_to_inseg_list(ecp, s); 361 insert_to_sec_list(ecp, s, 0); 362 363 /* Create internal .shstrtab section. */ 364 init_shstrtab(ecp); 365 366 if (elf_getshstrndx(ecp->ein, &indx) == 0) 367 errx(EXIT_FAILURE, "elf_getshstrndx failed: %s", 368 elf_errmsg(-1)); 369 370 reorder = 0; 371 is = NULL; 372 while ((is = elf_nextscn(ecp->ein, is)) != NULL) { 373 if (gelf_getshdr(is, &ish) == NULL) 374 errx(EXIT_FAILURE, "gelf_getshdr failed: %s", 375 elf_errmsg(-1)); 376 if ((name = elf_strptr(ecp->ein, indx, ish.sh_name)) == NULL) 377 errx(EXIT_FAILURE, "elf_strptr failed: %s", 378 elf_errmsg(-1)); 379 380 /* Skip sections to be removed. */ 381 if (is_remove_section(ecp, name)) 382 continue; 383 384 /* 385 * Relocation section need to be remove if the section 386 * it applies will be removed. 387 */ 388 if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA) 389 if (ish.sh_info != 0 && 390 is_remove_reloc_sec(ecp, ish.sh_info)) 391 continue; 392 393 /* 394 * Section groups should be removed if symbol table will 395 * be removed. (section group's signature stored in symbol 396 * table) 397 */ 398 if (ish.sh_type == SHT_GROUP && ecp->strip == STRIP_ALL) 399 continue; 400 401 /* Get section flags set by user. */ 402 sec_flags = get_section_flags(ecp, name); 403 404 /* Create internal section object. */ 405 if (strcmp(name, ".shstrtab") != 0) { 406 if ((s = calloc(1, sizeof(*s))) == NULL) 407 err(EXIT_FAILURE, "calloc failed"); 408 s->name = name; 409 s->is = is; 410 s->off = ish.sh_offset; 411 s->sz = ish.sh_size; 412 s->align = ish.sh_addralign; 413 s->type = ish.sh_type; 414 s->flags = ish.sh_flags; 415 s->vma = ish.sh_addr; 416 417 /* 418 * Search program headers to determine whether section 419 * is loadable, but if user explicitly set section flags 420 * while neither "load" nor "alloc" is set, we make the 421 * section unloadable. 422 * 423 * Sections in relocatable object is loadable if 424 * section flag SHF_ALLOC is set. 425 */ 426 if (sec_flags && 427 (sec_flags & (SF_LOAD | SF_ALLOC)) == 0) 428 s->loadable = 0; 429 else { 430 s->loadable = add_to_inseg_list(ecp, s); 431 if ((ecp->flags & RELOCATABLE) && 432 (ish.sh_flags & SHF_ALLOC)) 433 s->loadable = 1; 434 } 435 } else { 436 /* Assuming .shstrtab is "unloadable". */ 437 s = ecp->shstrtab; 438 s->off = ish.sh_offset; 439 } 440 441 oldndx = newndx = SHN_UNDEF; 442 if (strcmp(name, ".symtab") != 0 && 443 strcmp(name, ".strtab") != 0) { 444 if (!strcmp(name, ".shstrtab")) { 445 /* 446 * Add sections specified by --add-section and 447 * gnu debuglink. we want these sections have 448 * smaller index than .shstrtab section. 449 */ 450 if (ecp->debuglink != NULL) 451 add_gnu_debuglink(ecp); 452 if (ecp->flags & SEC_ADD) 453 insert_sections(ecp); 454 } 455 if ((s->os = elf_newscn(ecp->eout)) == NULL) 456 errx(EXIT_FAILURE, "elf_newscn failed: %s", 457 elf_errmsg(-1)); 458 if ((newndx = elf_ndxscn(s->os)) == SHN_UNDEF) 459 errx(EXIT_FAILURE, "elf_ndxscn failed: %s", 460 elf_errmsg(-1)); 461 } 462 if ((oldndx = elf_ndxscn(is)) == SHN_UNDEF) 463 errx(EXIT_FAILURE, "elf_ndxscn failed: %s", 464 elf_errmsg(-1)); 465 if (oldndx != SHN_UNDEF && newndx != SHN_UNDEF) 466 ecp->secndx[oldndx] = newndx; 467 468 /* 469 * If strip action is STRIP_NONDEBUG(only keep debug), 470 * change sections type of loadable sections and section 471 * groups to SHT_NOBITS, and the content of those sections 472 * will be discarded. However, SHT_NOTE sections should 473 * be kept. 474 */ 475 if (ecp->strip == STRIP_NONDEBUG) { 476 if (((ish.sh_flags & SHF_ALLOC) || 477 (ish.sh_flags & SHF_GROUP)) && 478 ish.sh_type != SHT_NOTE) 479 s->type = SHT_NOBITS; 480 } 481 482 check_section_rename(ecp, s); 483 484 /* create section header based on input object. */ 485 if (strcmp(name, ".symtab") != 0 && 486 strcmp(name, ".strtab") != 0 && 487 strcmp(name, ".shstrtab") != 0) { 488 copy_shdr(ecp, s, NULL, 0, sec_flags); 489 /* 490 * elfcopy puts .symtab, .strtab and .shstrtab 491 * sections in the end of the output object. 492 * If the input objects have more sections 493 * after any of these 3 sections, the section 494 * table will be reordered. section symbols 495 * should be regenerated for relocations. 496 */ 497 if (reorder) 498 ecp->flags &= ~SYMTAB_INTACT; 499 } else 500 reorder = 1; 501 502 if (strcmp(name, ".symtab") == 0) { 503 ecp->flags |= SYMTAB_EXIST; 504 ecp->symtab = s; 505 } 506 if (strcmp(name, ".strtab") == 0) 507 ecp->strtab = s; 508 509 insert_to_sec_list(ecp, s, 0); 510 } 511 elferr = elf_errno(); 512 if (elferr != 0) 513 errx(EXIT_FAILURE, "elf_nextscn failed: %s", 514 elf_errmsg(elferr)); 515 } 516 517 struct section * 518 insert_shtab(struct elfcopy *ecp, int tail) 519 { 520 struct section *s, *shtab; 521 GElf_Ehdr ieh; 522 int nsecs; 523 524 /* 525 * Treat section header table as a "pseudo" section, insert it 526 * into section list, so later it will get sorted and resynced 527 * just as normal sections. 528 */ 529 if ((shtab = calloc(1, sizeof(*shtab))) == NULL) 530 errx(EXIT_FAILURE, "calloc failed"); 531 if (!tail) { 532 /* 533 * "shoff" of input object is used as a hint for section 534 * resync later. 535 */ 536 if (gelf_getehdr(ecp->ein, &ieh) == NULL) 537 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 538 elf_errmsg(-1)); 539 shtab->off = ieh.e_shoff; 540 } else 541 shtab->off = 0; 542 /* Calculate number of sections in the output object. */ 543 nsecs = 0; 544 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 545 if (!s->pseudo) 546 nsecs++; 547 } 548 /* Remember there is always a null section, so we +1 here. */ 549 shtab->sz = gelf_fsize(ecp->eout, ELF_T_SHDR, nsecs + 1, EV_CURRENT); 550 if (shtab->sz == 0) 551 errx(EXIT_FAILURE, "gelf_fsize() failed: %s", elf_errmsg(-1)); 552 shtab->align = (ecp->oec == ELFCLASS32 ? 4 : 8); 553 shtab->loadable = 0; 554 shtab->pseudo = 1; 555 insert_to_sec_list(ecp, shtab, tail); 556 557 return (shtab); 558 } 559 560 void 561 copy_content(struct elfcopy *ecp) 562 { 563 struct section *s; 564 565 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 566 /* Skip pseudo section. */ 567 if (s->pseudo) 568 continue; 569 570 /* Skip special sections. */ 571 if (strcmp(s->name, ".symtab") == 0 || 572 strcmp(s->name, ".strtab") == 0 || 573 strcmp(s->name, ".shstrtab") == 0) 574 continue; 575 576 /* 577 * If strip action is STRIP_ALL, relocation info need 578 * to be stripped. Skip filtering otherwisw. 579 */ 580 if (ecp->strip == STRIP_ALL && 581 (s->type == SHT_REL || s->type == SHT_RELA)) 582 filter_reloc(ecp, s); 583 584 /* 585 * The section indices in the SHT_GROUP section needs 586 * to be updated since we might have stripped some 587 * sections and changed section numbering. 588 */ 589 if (s->type == SHT_GROUP) 590 update_section_group(ecp, s); 591 592 if (is_modify_section(ecp, s->name)) 593 modify_section(ecp, s); 594 595 copy_data(s); 596 597 /* 598 * If symbol table is modified, relocation info might 599 * need update, as symbol index may have changed. 600 */ 601 if ((ecp->flags & SYMTAB_INTACT) == 0 && 602 (ecp->flags & SYMTAB_EXIST) && 603 (s->type == SHT_REL || s->type == SHT_RELA)) 604 update_reloc(ecp, s); 605 606 if (is_print_section(ecp, s->name)) 607 print_section(s); 608 } 609 } 610 611 612 /* 613 * Update section group section. The section indices in the SHT_GROUP 614 * section need update after section numbering changed. 615 */ 616 static void 617 update_section_group(struct elfcopy *ecp, struct section *s) 618 { 619 GElf_Shdr ish; 620 Elf_Data *id; 621 uint32_t *ws, *wd; 622 uint64_t n; 623 size_t ishnum; 624 int i, j; 625 626 if (!elf_getshnum(ecp->ein, &ishnum)) 627 errx(EXIT_FAILURE, "elf_getshnum failed: %s", 628 elf_errmsg(-1)); 629 630 if (gelf_getshdr(s->is, &ish) == NULL) 631 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 632 elf_errmsg(-1)); 633 634 if ((id = elf_getdata(s->is, NULL)) == NULL) 635 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 636 elf_errmsg(-1)); 637 638 if (ish.sh_size == 0) 639 return; 640 641 if (ish.sh_entsize == 0) 642 ish.sh_entsize = 4; 643 644 ws = id->d_buf; 645 646 /* We only support COMDAT section. */ 647 #ifndef GRP_COMDAT 648 #define GRP_COMDAT 0x1 649 #endif 650 if ((*ws & GRP_COMDAT) == 0) 651 return; 652 653 if ((s->buf = malloc(ish.sh_size)) == NULL) 654 err(EXIT_FAILURE, "malloc failed"); 655 656 s->sz = ish.sh_size; 657 658 wd = s->buf; 659 660 /* Copy the flag word as-is. */ 661 *wd = *ws; 662 663 /* Update the section indices. */ 664 n = ish.sh_size / ish.sh_entsize; 665 for(i = 1, j = 1; (uint64_t)i < n; i++) { 666 if (ws[i] != SHN_UNDEF && ws[i] < ishnum && 667 ecp->secndx[ws[i]] != 0) 668 wd[j++] = ecp->secndx[ws[i]]; 669 else 670 s->sz -= 4; 671 } 672 673 s->nocopy = 1; 674 } 675 676 /* 677 * Filter relocation entries, only keep those entries whose 678 * symbol is in the keep list. 679 */ 680 static void 681 filter_reloc(struct elfcopy *ecp, struct section *s) 682 { 683 const char *name; 684 GElf_Shdr ish; 685 GElf_Rel rel; 686 GElf_Rela rela; 687 Elf32_Rel *rel32; 688 Elf64_Rel *rel64; 689 Elf32_Rela *rela32; 690 Elf64_Rela *rela64; 691 Elf_Data *id; 692 uint64_t cap, n, nrels, sym; 693 int elferr, i; 694 695 if (gelf_getshdr(s->is, &ish) == NULL) 696 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 697 elf_errmsg(-1)); 698 699 /* We don't want to touch relocation info for dynamic symbols. */ 700 if ((ecp->flags & SYMTAB_EXIST) == 0) { 701 /* 702 * No symbol table in output. If sh_link points to a section 703 * that exists in the output object, this relocation section 704 * is for dynamic symbols. Don't touch it. 705 */ 706 if (ish.sh_link != 0 && ecp->secndx[ish.sh_link] != 0) 707 return; 708 } else { 709 /* Symbol table exist, check if index equals. */ 710 if (ish.sh_link != elf_ndxscn(ecp->symtab->is)) 711 return; 712 } 713 714 #define COPYREL(REL, SZ) do { \ 715 if (nrels == 0) { \ 716 if ((REL##SZ = malloc(cap * \ 717 sizeof(*REL##SZ))) == NULL) \ 718 err(EXIT_FAILURE, "malloc failed"); \ 719 } \ 720 if (nrels >= cap) { \ 721 cap *= 2; \ 722 if ((REL##SZ = realloc(REL##SZ, cap * \ 723 sizeof(*REL##SZ))) == NULL) \ 724 err(EXIT_FAILURE, "realloc failed"); \ 725 } \ 726 REL##SZ[nrels].r_offset = REL.r_offset; \ 727 REL##SZ[nrels].r_info = REL.r_info; \ 728 if (s->type == SHT_RELA) \ 729 rela##SZ[nrels].r_addend = rela.r_addend; \ 730 nrels++; \ 731 } while (0) 732 733 nrels = 0; 734 cap = 4; /* keep list is usually small. */ 735 rel32 = NULL; 736 rel64 = NULL; 737 rela32 = NULL; 738 rela64 = NULL; 739 if ((id = elf_getdata(s->is, NULL)) == NULL) 740 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 741 elf_errmsg(-1)); 742 n = ish.sh_size / ish.sh_entsize; 743 for(i = 0; (uint64_t)i < n; i++) { 744 if (s->type == SHT_REL) { 745 if (gelf_getrel(id, i, &rel) != &rel) 746 errx(EXIT_FAILURE, "gelf_getrel failed: %s", 747 elf_errmsg(-1)); 748 sym = GELF_R_SYM(rel.r_info); 749 } else { 750 if (gelf_getrela(id, i, &rela) != &rela) 751 errx(EXIT_FAILURE, "gelf_getrel failed: %s", 752 elf_errmsg(-1)); 753 sym = GELF_R_SYM(rela.r_info); 754 } 755 /* 756 * If a relocation references a symbol and we are omitting 757 * either that symbol or the entire symbol table we cannot 758 * produce valid output, and so just omit the relocation. 759 * Broken output like this is generally not useful, but some 760 * uses of elfcopy/strip rely on it - for example, GCC's build 761 * process uses it to check for build reproducibility by 762 * stripping objects and comparing them. 763 * 764 * Relocations that do not reference a symbol are retained. 765 */ 766 if (sym != 0) { 767 if (ish.sh_link == 0 || ecp->secndx[ish.sh_link] == 0) 768 continue; 769 name = elf_strptr(ecp->ein, elf_ndxscn(ecp->strtab->is), 770 sym); 771 if (name == NULL) 772 errx(EXIT_FAILURE, "elf_strptr failed: %s", 773 elf_errmsg(-1)); 774 if (lookup_symop_list(ecp, name, SYMOP_KEEP) == NULL) 775 continue; 776 } 777 if (ecp->oec == ELFCLASS32) { 778 if (s->type == SHT_REL) 779 COPYREL(rel, 32); 780 else 781 COPYREL(rela, 32); 782 } else { 783 if (s->type == SHT_REL) 784 COPYREL(rel, 64); 785 else 786 COPYREL(rela, 64); 787 } 788 } 789 elferr = elf_errno(); 790 if (elferr != 0) 791 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 792 elf_errmsg(elferr)); 793 794 if (ecp->oec == ELFCLASS32) { 795 if (s->type == SHT_REL) 796 s->buf = rel32; 797 else 798 s->buf = rela32; 799 } else { 800 if (s->type == SHT_REL) 801 s->buf = rel64; 802 else 803 s->buf = rela64; 804 } 805 s->sz = gelf_fsize(ecp->eout, (s->type == SHT_REL ? ELF_T_REL : 806 ELF_T_RELA), nrels, EV_CURRENT); 807 s->nocopy = 1; 808 } 809 810 static void 811 update_reloc(struct elfcopy *ecp, struct section *s) 812 { 813 GElf_Shdr osh; 814 GElf_Rel rel; 815 GElf_Rela rela; 816 Elf_Data *od; 817 uint64_t n; 818 int i; 819 820 #define UPDATEREL(REL) do { \ 821 if (gelf_get##REL(od, i, &REL) != &REL) \ 822 errx(EXIT_FAILURE, "gelf_get##REL failed: %s", \ 823 elf_errmsg(-1)); \ 824 REL.r_info = GELF_R_INFO(ecp->symndx[GELF_R_SYM(REL.r_info)], \ 825 GELF_R_TYPE(REL.r_info)); \ 826 if (!gelf_update_##REL(od, i, &REL)) \ 827 errx(EXIT_FAILURE, "gelf_update_##REL failed: %s", \ 828 elf_errmsg(-1)); \ 829 } while(0) 830 831 if (s->sz == 0) 832 return; 833 if (gelf_getshdr(s->os, &osh) == NULL) 834 errx(EXIT_FAILURE, "gelf_getehdr() failed: %s", 835 elf_errmsg(-1)); 836 /* Only process .symtab reloc info. */ 837 if (osh.sh_link != elf_ndxscn(ecp->symtab->is)) 838 return; 839 if ((od = elf_getdata(s->os, NULL)) == NULL) 840 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 841 elf_errmsg(-1)); 842 n = osh.sh_size / osh.sh_entsize; 843 for(i = 0; (uint64_t)i < n; i++) { 844 if (s->type == SHT_REL) 845 UPDATEREL(rel); 846 else 847 UPDATEREL(rela); 848 } 849 } 850 851 static void 852 pad_section(struct elfcopy *ecp, struct section *s) 853 { 854 GElf_Shdr osh; 855 Elf_Data *od; 856 857 if (s == NULL || s->pad_sz == 0) 858 return; 859 860 if ((s->pad = malloc(s->pad_sz)) == NULL) 861 err(EXIT_FAILURE, "malloc failed"); 862 memset(s->pad, ecp->fill, s->pad_sz); 863 864 /* Create a new Elf_Data to contain the padding bytes. */ 865 if ((od = elf_newdata(s->os)) == NULL) 866 errx(EXIT_FAILURE, "elf_newdata() failed: %s", 867 elf_errmsg(-1)); 868 od->d_align = 1; 869 od->d_off = s->sz; 870 od->d_buf = s->pad; 871 od->d_type = ELF_T_BYTE; 872 od->d_size = s->pad_sz; 873 od->d_version = EV_CURRENT; 874 875 /* Update section header. */ 876 if (gelf_getshdr(s->os, &osh) == NULL) 877 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 878 elf_errmsg(-1)); 879 osh.sh_size = s->sz + s->pad_sz; 880 if (!gelf_update_shdr(s->os, &osh)) 881 errx(EXIT_FAILURE, "elf_update_shdr failed: %s", 882 elf_errmsg(-1)); 883 } 884 885 void 886 resync_sections(struct elfcopy *ecp) 887 { 888 struct section *s, *ps; 889 GElf_Shdr osh; 890 uint64_t off; 891 int first; 892 893 ps = NULL; 894 first = 1; 895 off = 0; 896 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 897 if (first) { 898 off = s->off; 899 first = 0; 900 } 901 902 /* 903 * Ignore TLS sections with load address 0 and without 904 * content. We don't need to adjust their file offset or 905 * VMA, only the size matters. 906 */ 907 if (s->seg_tls != NULL && s->type == SHT_NOBITS && 908 s->off == 0) 909 continue; 910 911 /* Align section offset. */ 912 if (s->align == 0) 913 s->align = 1; 914 if (off <= s->off) { 915 if (!s->loadable || (ecp->flags & RELOCATABLE)) 916 s->off = roundup(off, s->align); 917 } else { 918 if (s->loadable && (ecp->flags & RELOCATABLE) == 0) 919 warnx("moving loadable section %s, " 920 "is this intentional?", s->name); 921 s->off = roundup(off, s->align); 922 } 923 924 /* Calculate next section offset. */ 925 off = s->off; 926 if (s->pseudo || (s->type != SHT_NOBITS && s->type != SHT_NULL)) 927 off += s->sz; 928 929 if (s->pseudo) { 930 ps = NULL; 931 continue; 932 } 933 934 /* Count padding bytes added through --pad-to. */ 935 if (s->pad_sz > 0) 936 off += s->pad_sz; 937 938 /* Update section header accordingly. */ 939 if (gelf_getshdr(s->os, &osh) == NULL) 940 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 941 elf_errmsg(-1)); 942 osh.sh_addr = s->vma; 943 osh.sh_offset = s->off; 944 osh.sh_size = s->sz; 945 if (!gelf_update_shdr(s->os, &osh)) 946 errx(EXIT_FAILURE, "elf_update_shdr failed: %s", 947 elf_errmsg(-1)); 948 949 /* Add padding for previous section, if need. */ 950 if (ps != NULL) { 951 if (ps->pad_sz > 0) { 952 /* Apply padding added by --pad-to. */ 953 pad_section(ecp, ps); 954 } else if ((ecp->flags & GAP_FILL) && 955 (ps->off + ps->sz < s->off)) { 956 /* 957 * Fill the gap between sections by padding 958 * the section with lower address. 959 */ 960 ps->pad_sz = s->off - (ps->off + ps->sz); 961 pad_section(ecp, ps); 962 } 963 } 964 965 ps = s; 966 } 967 968 /* Pad the last section, if need. */ 969 if (ps != NULL && ps->pad_sz > 0) 970 pad_section(ecp, ps); 971 } 972 973 static void 974 modify_section(struct elfcopy *ecp, struct section *s) 975 { 976 struct sec_action *sac; 977 size_t srcsz, dstsz, p, len; 978 char *b, *c, *d, *src, *end; 979 int dupe; 980 981 src = read_section(s, &srcsz); 982 if (src == NULL || srcsz == 0) { 983 /* For empty section, we proceed if we need to append. */ 984 if (!is_append_section(ecp, s->name)) 985 return; 986 } 987 988 /* Allocate buffer needed for new section data. */ 989 dstsz = srcsz; 990 if (is_append_section(ecp, s->name)) { 991 sac = lookup_sec_act(ecp, s->name, 0); 992 dstsz += strlen(sac->string) + 1; 993 } 994 if ((b = malloc(dstsz)) == NULL) 995 err(EXIT_FAILURE, "malloc failed"); 996 s->buf = b; 997 998 /* Compress section. */ 999 p = 0; 1000 if (is_compress_section(ecp, s->name)) { 1001 end = src + srcsz; 1002 for(c = src; c < end;) { 1003 len = 0; 1004 while(c + len < end && c[len] != '\0') 1005 len++; 1006 if (c + len == end) { 1007 /* XXX should we warn here? */ 1008 strncpy(&b[p], c, len); 1009 p += len; 1010 break; 1011 } 1012 dupe = 0; 1013 for (d = b; d < b + p; ) { 1014 if (strcmp(d, c) == 0) { 1015 dupe = 1; 1016 break; 1017 } 1018 d += strlen(d) + 1; 1019 } 1020 if (!dupe) { 1021 strncpy(&b[p], c, len); 1022 b[p + len] = '\0'; 1023 p += len + 1; 1024 } 1025 c += len + 1; 1026 } 1027 } else { 1028 memcpy(b, src, srcsz); 1029 p += srcsz; 1030 } 1031 1032 /* Append section. */ 1033 if (is_append_section(ecp, s->name)) { 1034 sac = lookup_sec_act(ecp, s->name, 0); 1035 len = strlen(sac->string); 1036 strncpy(&b[p], sac->string, len); 1037 b[p + len] = '\0'; 1038 p += len + 1; 1039 } 1040 1041 s->sz = p; 1042 s->nocopy = 1; 1043 } 1044 1045 static void 1046 print_data(const char *d, size_t sz) 1047 { 1048 const char *c; 1049 1050 for (c = d; c < d + sz; c++) { 1051 if (*c == '\0') 1052 putchar('\n'); 1053 else 1054 putchar(*c); 1055 } 1056 } 1057 1058 static void 1059 print_section(struct section *s) 1060 { 1061 Elf_Data *id; 1062 int elferr; 1063 1064 if (s->buf != NULL && s->sz > 0) { 1065 print_data(s->buf, s->sz); 1066 } else { 1067 id = NULL; 1068 while ((id = elf_getdata(s->is, id)) != NULL || 1069 (id = elf_rawdata(s->is, id)) != NULL) { 1070 (void) elf_errno(); 1071 print_data(id->d_buf, id->d_size); 1072 } 1073 elferr = elf_errno(); 1074 if (elferr != 0) 1075 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 1076 elf_errmsg(elferr)); 1077 } 1078 putchar('\n'); 1079 } 1080 1081 static void * 1082 read_section(struct section *s, size_t *size) 1083 { 1084 Elf_Data *id; 1085 char *b; 1086 size_t sz; 1087 int elferr; 1088 1089 sz = 0; 1090 b = NULL; 1091 id = NULL; 1092 while ((id = elf_getdata(s->is, id)) != NULL || 1093 (id = elf_rawdata(s->is, id)) != NULL) { 1094 (void) elf_errno(); 1095 if (b == NULL) 1096 b = malloc(id->d_size); 1097 else 1098 b = malloc(sz + id->d_size); 1099 if (b == NULL) 1100 err(EXIT_FAILURE, "malloc or realloc failed"); 1101 1102 memcpy(&b[sz], id->d_buf, id->d_size); 1103 sz += id->d_size; 1104 } 1105 elferr = elf_errno(); 1106 if (elferr != 0) 1107 errx(EXIT_FAILURE, "elf_getdata() failed: %s", 1108 elf_errmsg(elferr)); 1109 1110 *size = sz; 1111 1112 return (b); 1113 } 1114 1115 void 1116 copy_shdr(struct elfcopy *ecp, struct section *s, const char *name, int copy, 1117 int sec_flags) 1118 { 1119 GElf_Shdr ish, osh; 1120 1121 if (gelf_getshdr(s->is, &ish) == NULL) 1122 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 1123 elf_errmsg(-1)); 1124 if (gelf_getshdr(s->os, &osh) == NULL) 1125 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 1126 elf_errmsg(-1)); 1127 1128 if (copy) 1129 (void) memcpy(&osh, &ish, sizeof(ish)); 1130 else { 1131 osh.sh_type = s->type; 1132 osh.sh_addr = s->vma; 1133 osh.sh_offset = s->off; 1134 osh.sh_size = s->sz; 1135 osh.sh_link = ish.sh_link; 1136 osh.sh_info = ish.sh_info; 1137 osh.sh_addralign = s->align; 1138 osh.sh_entsize = ish.sh_entsize; 1139 1140 if (sec_flags) { 1141 osh.sh_flags = 0; 1142 if (sec_flags & SF_ALLOC) 1143 osh.sh_flags |= SHF_ALLOC; 1144 if ((sec_flags & SF_READONLY) == 0) 1145 osh.sh_flags |= SHF_WRITE; 1146 if (sec_flags & SF_CODE) 1147 osh.sh_flags |= SHF_EXECINSTR; 1148 if ((sec_flags & SF_CONTENTS) && 1149 s->type == SHT_NOBITS && s->sz > 0) { 1150 /* 1151 * Convert SHT_NOBITS section to section with 1152 * (zero'ed) content on file. 1153 */ 1154 osh.sh_type = s->type = SHT_PROGBITS; 1155 if ((s->buf = calloc(1, s->sz)) == NULL) 1156 err(EXIT_FAILURE, "malloc failed"); 1157 s->nocopy = 1; 1158 } 1159 } else { 1160 osh.sh_flags = ish.sh_flags; 1161 /* 1162 * Newer binutils as(1) emits the section flag 1163 * SHF_INFO_LINK for relocation sections. elfcopy 1164 * emits this flag in the output section if it's 1165 * missing in the input section, to remain compatible 1166 * with binutils. 1167 */ 1168 if (ish.sh_type == SHT_REL || ish.sh_type == SHT_RELA) 1169 osh.sh_flags |= SHF_INFO_LINK; 1170 } 1171 } 1172 1173 if (name == NULL) 1174 add_to_shstrtab(ecp, s->name); 1175 else 1176 add_to_shstrtab(ecp, name); 1177 1178 if (!gelf_update_shdr(s->os, &osh)) 1179 errx(EXIT_FAILURE, "elf_update_shdr failed: %s", 1180 elf_errmsg(-1)); 1181 } 1182 1183 void 1184 copy_data(struct section *s) 1185 { 1186 Elf_Data *id, *od; 1187 int elferr; 1188 1189 if (s->nocopy && s->buf == NULL) 1190 return; 1191 1192 if ((id = elf_getdata(s->is, NULL)) == NULL) { 1193 (void) elf_errno(); 1194 if ((id = elf_rawdata(s->is, NULL)) == NULL) { 1195 elferr = elf_errno(); 1196 if (elferr != 0) 1197 errx(EXIT_FAILURE, "failed to read section:" 1198 " %s", s->name); 1199 return; 1200 } 1201 } 1202 1203 if ((od = elf_newdata(s->os)) == NULL) 1204 errx(EXIT_FAILURE, "elf_newdata() failed: %s", 1205 elf_errmsg(-1)); 1206 1207 if (s->nocopy) { 1208 /* Use s->buf as content if s->nocopy is set. */ 1209 od->d_align = id->d_align; 1210 od->d_off = 0; 1211 od->d_buf = s->buf; 1212 od->d_type = id->d_type; 1213 od->d_size = s->sz; 1214 od->d_version = id->d_version; 1215 } else { 1216 od->d_align = id->d_align; 1217 od->d_off = id->d_off; 1218 od->d_buf = id->d_buf; 1219 od->d_type = id->d_type; 1220 od->d_size = id->d_size; 1221 od->d_version = id->d_version; 1222 } 1223 1224 /* 1225 * Alignment Fixup. libelf does not allow the alignment for 1226 * Elf_Data descriptor to be set to 0. In this case we workaround 1227 * it by setting the alignment to 1. 1228 * 1229 * According to the ELF ABI, alignment 0 and 1 has the same 1230 * meaning: the section has no alignment constraints. 1231 */ 1232 if (od->d_align == 0) 1233 od->d_align = 1; 1234 } 1235 1236 struct section * 1237 create_external_section(struct elfcopy *ecp, const char *name, char *newname, 1238 void *buf, uint64_t size, uint64_t off, uint64_t stype, Elf_Type dtype, 1239 uint64_t flags, uint64_t align, uint64_t vma, int loadable) 1240 { 1241 struct section *s; 1242 Elf_Scn *os; 1243 Elf_Data *od; 1244 GElf_Shdr osh; 1245 1246 if ((os = elf_newscn(ecp->eout)) == NULL) 1247 errx(EXIT_FAILURE, "elf_newscn() failed: %s", 1248 elf_errmsg(-1)); 1249 if ((s = calloc(1, sizeof(*s))) == NULL) 1250 err(EXIT_FAILURE, "calloc failed"); 1251 s->name = name; 1252 s->newname = newname; /* needs to be free()'ed */ 1253 s->off = off; 1254 s->sz = size; 1255 s->vma = vma; 1256 s->align = align; 1257 s->loadable = loadable; 1258 s->is = NULL; 1259 s->os = os; 1260 s->type = stype; 1261 s->nocopy = 1; 1262 insert_to_sec_list(ecp, s, 1); 1263 1264 if (gelf_getshdr(os, &osh) == NULL) 1265 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 1266 elf_errmsg(-1)); 1267 osh.sh_flags = flags; 1268 osh.sh_type = s->type; 1269 osh.sh_addr = s->vma; 1270 osh.sh_addralign = s->align; 1271 if (!gelf_update_shdr(os, &osh)) 1272 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", 1273 elf_errmsg(-1)); 1274 add_to_shstrtab(ecp, name); 1275 1276 if (buf != NULL && size != 0) { 1277 if ((od = elf_newdata(os)) == NULL) 1278 errx(EXIT_FAILURE, "elf_newdata() failed: %s", 1279 elf_errmsg(-1)); 1280 od->d_align = align; 1281 od->d_off = 0; 1282 od->d_buf = buf; 1283 od->d_size = size; 1284 od->d_type = dtype; 1285 od->d_version = EV_CURRENT; 1286 } 1287 1288 /* 1289 * Clear SYMTAB_INTACT, as we probably need to update/add new 1290 * STT_SECTION symbols into the symbol table. 1291 */ 1292 ecp->flags &= ~SYMTAB_INTACT; 1293 1294 return (s); 1295 } 1296 1297 /* 1298 * Insert sections specified by --add-section to the end of section list. 1299 */ 1300 static void 1301 insert_sections(struct elfcopy *ecp) 1302 { 1303 struct sec_add *sa; 1304 struct section *s; 1305 size_t off; 1306 uint64_t stype; 1307 1308 /* Put these sections in the end of current list. */ 1309 off = 0; 1310 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 1311 if (s->type != SHT_NOBITS && s->type != SHT_NULL) 1312 off = s->off + s->sz; 1313 else 1314 off = s->off; 1315 } 1316 1317 STAILQ_FOREACH(sa, &ecp->v_sadd, sadd_list) { 1318 1319 /* TODO: Add section header vma/lma, flag changes here */ 1320 1321 /* 1322 * The default section type for user added section is 1323 * SHT_PROGBITS. If the section name match certain patterns, 1324 * elfcopy will try to set a more appropriate section type. 1325 * However, data type is always set to ELF_T_BYTE and no 1326 * translation is performed by libelf. 1327 */ 1328 stype = SHT_PROGBITS; 1329 if (strcmp(sa->name, ".note") == 0 || 1330 strncmp(sa->name, ".note.", strlen(".note.")) == 0) 1331 stype = SHT_NOTE; 1332 1333 (void) create_external_section(ecp, sa->name, NULL, sa->content, 1334 sa->size, off, stype, ELF_T_BYTE, 0, 1, 0, 0); 1335 } 1336 } 1337 1338 void 1339 add_to_shstrtab(struct elfcopy *ecp, const char *name) 1340 { 1341 struct section *s; 1342 1343 s = ecp->shstrtab; 1344 insert_to_strtab(s, name); 1345 } 1346 1347 void 1348 update_shdr(struct elfcopy *ecp, int update_link) 1349 { 1350 struct section *s; 1351 GElf_Shdr osh; 1352 int elferr; 1353 1354 TAILQ_FOREACH(s, &ecp->v_sec, sec_list) { 1355 if (s->pseudo) 1356 continue; 1357 1358 if (gelf_getshdr(s->os, &osh) == NULL) 1359 errx(EXIT_FAILURE, "gelf_getshdr failed: %s", 1360 elf_errmsg(-1)); 1361 1362 /* Find section name in string table and set sh_name. */ 1363 osh.sh_name = lookup_string(ecp->shstrtab, s->name); 1364 1365 /* 1366 * sh_link needs to be updated, since the index of the 1367 * linked section might have changed. 1368 */ 1369 if (update_link && osh.sh_link != 0) 1370 osh.sh_link = ecp->secndx[osh.sh_link]; 1371 1372 /* 1373 * sh_info of relocation section links to the section to which 1374 * its relocation info applies. So it may need update as well. 1375 */ 1376 if ((s->type == SHT_REL || s->type == SHT_RELA) && 1377 osh.sh_info != 0) 1378 osh.sh_info = ecp->secndx[osh.sh_info]; 1379 1380 /* 1381 * sh_info of SHT_GROUP section needs to point to the correct 1382 * string in the symbol table. 1383 */ 1384 if (s->type == SHT_GROUP && (ecp->flags & SYMTAB_EXIST) && 1385 (ecp->flags & SYMTAB_INTACT) == 0) 1386 osh.sh_info = ecp->symndx[osh.sh_info]; 1387 1388 if (!gelf_update_shdr(s->os, &osh)) 1389 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", 1390 elf_errmsg(-1)); 1391 } 1392 elferr = elf_errno(); 1393 if (elferr != 0) 1394 errx(EXIT_FAILURE, "elf_nextscn failed: %s", 1395 elf_errmsg(elferr)); 1396 } 1397 1398 void 1399 init_shstrtab(struct elfcopy *ecp) 1400 { 1401 struct section *s; 1402 1403 if ((ecp->shstrtab = calloc(1, sizeof(*ecp->shstrtab))) == NULL) 1404 err(EXIT_FAILURE, "calloc failed"); 1405 s = ecp->shstrtab; 1406 s->name = ".shstrtab"; 1407 s->is = NULL; 1408 s->sz = 0; 1409 s->align = 1; 1410 s->loadable = 0; 1411 s->type = SHT_STRTAB; 1412 s->vma = 0; 1413 1414 insert_to_strtab(s, ""); 1415 insert_to_strtab(s, ".symtab"); 1416 insert_to_strtab(s, ".strtab"); 1417 insert_to_strtab(s, ".shstrtab"); 1418 } 1419 1420 void 1421 set_shstrtab(struct elfcopy *ecp) 1422 { 1423 struct section *s; 1424 Elf_Data *data; 1425 GElf_Shdr sh; 1426 1427 s = ecp->shstrtab; 1428 1429 if (s->os == NULL) { 1430 /* Input object does not contain .shstrtab section */ 1431 if ((s->os = elf_newscn(ecp->eout)) == NULL) 1432 errx(EXIT_FAILURE, "elf_newscn failed: %s", 1433 elf_errmsg(-1)); 1434 insert_to_sec_list(ecp, s, 1); 1435 } 1436 1437 if (gelf_getshdr(s->os, &sh) == NULL) 1438 errx(EXIT_FAILURE, "gelf_getshdr() failed: %s", 1439 elf_errmsg(-1)); 1440 sh.sh_addr = 0; 1441 sh.sh_addralign = 1; 1442 sh.sh_offset = s->off; 1443 sh.sh_type = SHT_STRTAB; 1444 sh.sh_flags = 0; 1445 sh.sh_entsize = 0; 1446 sh.sh_info = 0; 1447 sh.sh_link = 0; 1448 1449 if ((data = elf_newdata(s->os)) == NULL) 1450 errx(EXIT_FAILURE, "elf_newdata() failed: %s", 1451 elf_errmsg(-1)); 1452 1453 /* 1454 * If we don't have a symbol table, skip those a few bytes 1455 * which are reserved for this in the beginning of shstrtab. 1456 */ 1457 if (!(ecp->flags & SYMTAB_EXIST)) { 1458 s->sz -= sizeof(".symtab\0.strtab"); 1459 memmove(s->buf, (char *)s->buf + sizeof(".symtab\0.strtab"), 1460 s->sz); 1461 } 1462 1463 sh.sh_size = s->sz; 1464 if (!gelf_update_shdr(s->os, &sh)) 1465 errx(EXIT_FAILURE, "gelf_update_shdr() failed: %s", 1466 elf_errmsg(-1)); 1467 1468 data->d_align = 1; 1469 data->d_buf = s->buf; 1470 data->d_size = s->sz; 1471 data->d_off = 0; 1472 data->d_type = ELF_T_BYTE; 1473 data->d_version = EV_CURRENT; 1474 1475 if (!elf_setshstrndx(ecp->eout, elf_ndxscn(s->os))) 1476 errx(EXIT_FAILURE, "elf_setshstrndx() failed: %s", 1477 elf_errmsg(-1)); 1478 } 1479 1480 void 1481 add_section(struct elfcopy *ecp, const char *arg) 1482 { 1483 struct sec_add *sa; 1484 struct stat sb; 1485 const char *s, *fn; 1486 FILE *fp; 1487 int len; 1488 1489 if ((s = strchr(arg, '=')) == NULL) 1490 errx(EXIT_FAILURE, 1491 "illegal format for --add-section option"); 1492 if ((sa = malloc(sizeof(*sa))) == NULL) 1493 err(EXIT_FAILURE, "malloc failed"); 1494 1495 len = s - arg; 1496 if ((sa->name = malloc(len + 1)) == NULL) 1497 err(EXIT_FAILURE, "malloc failed"); 1498 strncpy(sa->name, arg, len); 1499 sa->name[len] = '\0'; 1500 1501 fn = s + 1; 1502 if (stat(fn, &sb) == -1) 1503 err(EXIT_FAILURE, "stat failed"); 1504 sa->size = sb.st_size; 1505 if (sa->size > 0) { 1506 if ((sa->content = malloc(sa->size)) == NULL) 1507 err(EXIT_FAILURE, "malloc failed"); 1508 if ((fp = fopen(fn, "r")) == NULL) 1509 err(EXIT_FAILURE, "can not open %s", fn); 1510 if (fread(sa->content, 1, sa->size, fp) == 0 || 1511 ferror(fp)) 1512 err(EXIT_FAILURE, "fread failed"); 1513 fclose(fp); 1514 } else 1515 sa->content = NULL; 1516 1517 STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list); 1518 ecp->flags |= SEC_ADD; 1519 } 1520 1521 void 1522 free_sec_add(struct elfcopy *ecp) 1523 { 1524 struct sec_add *sa, *sa_temp; 1525 1526 STAILQ_FOREACH_SAFE(sa, &ecp->v_sadd, sadd_list, sa_temp) { 1527 STAILQ_REMOVE(&ecp->v_sadd, sa, sec_add, sadd_list); 1528 free(sa->name); 1529 free(sa->content); 1530 free(sa); 1531 } 1532 } 1533 1534 static void 1535 add_gnu_debuglink(struct elfcopy *ecp) 1536 { 1537 struct sec_add *sa; 1538 struct stat sb; 1539 FILE *fp; 1540 char *fnbase, *buf; 1541 int crc_off; 1542 int crc; 1543 1544 if (ecp->debuglink == NULL) 1545 return; 1546 1547 /* Read debug file content. */ 1548 if ((sa = malloc(sizeof(*sa))) == NULL) 1549 err(EXIT_FAILURE, "malloc failed"); 1550 if ((sa->name = strdup(".gnu_debuglink")) == NULL) 1551 err(EXIT_FAILURE, "strdup failed"); 1552 if (stat(ecp->debuglink, &sb) == -1) 1553 err(EXIT_FAILURE, "stat failed"); 1554 if (sb.st_size == 0) 1555 errx(EXIT_FAILURE, "empty debug link target %s", 1556 ecp->debuglink); 1557 if ((buf = malloc(sb.st_size)) == NULL) 1558 err(EXIT_FAILURE, "malloc failed"); 1559 if ((fp = fopen(ecp->debuglink, "r")) == NULL) 1560 err(EXIT_FAILURE, "can not open %s", ecp->debuglink); 1561 if (fread(buf, 1, sb.st_size, fp) == 0 || 1562 ferror(fp)) 1563 err(EXIT_FAILURE, "fread failed"); 1564 fclose(fp); 1565 1566 /* Calculate crc checksum. */ 1567 crc = calc_crc32(buf, sb.st_size, 0xFFFFFFFF); 1568 free(buf); 1569 1570 /* Calculate section size and the offset to store crc checksum. */ 1571 if ((fnbase = basename(ecp->debuglink)) == NULL) 1572 err(EXIT_FAILURE, "basename failed"); 1573 crc_off = roundup(strlen(fnbase) + 1, 4); 1574 sa->size = crc_off + 4; 1575 1576 /* Section content. */ 1577 if ((sa->content = calloc(1, sa->size)) == NULL) 1578 err(EXIT_FAILURE, "malloc failed"); 1579 strncpy(sa->content, fnbase, strlen(fnbase)); 1580 if (ecp->oed == ELFDATA2LSB) { 1581 sa->content[crc_off] = crc & 0xFF; 1582 sa->content[crc_off + 1] = (crc >> 8) & 0xFF; 1583 sa->content[crc_off + 2] = (crc >> 16) & 0xFF; 1584 sa->content[crc_off + 3] = crc >> 24; 1585 } else { 1586 sa->content[crc_off] = crc >> 24; 1587 sa->content[crc_off + 1] = (crc >> 16) & 0xFF; 1588 sa->content[crc_off + 2] = (crc >> 8) & 0xFF; 1589 sa->content[crc_off + 3] = crc & 0xFF; 1590 } 1591 1592 STAILQ_INSERT_TAIL(&ecp->v_sadd, sa, sadd_list); 1593 ecp->flags |= SEC_ADD; 1594 } 1595 1596 static void 1597 insert_to_strtab(struct section *t, const char *s) 1598 { 1599 const char *r; 1600 char *b, *c; 1601 size_t len, slen; 1602 int append; 1603 1604 if (t->sz == 0) { 1605 t->cap = 512; 1606 if ((t->buf = malloc(t->cap)) == NULL) 1607 err(EXIT_FAILURE, "malloc failed"); 1608 } 1609 1610 slen = strlen(s); 1611 append = 0; 1612 b = t->buf; 1613 for (c = b; c < b + t->sz;) { 1614 len = strlen(c); 1615 if (!append && len >= slen) { 1616 r = c + (len - slen); 1617 if (strcmp(r, s) == 0) 1618 return; 1619 } else if (len < slen && len != 0) { 1620 r = s + (slen - len); 1621 if (strcmp(c, r) == 0) { 1622 t->sz -= len + 1; 1623 memmove(c, c + len + 1, t->sz - (c - b)); 1624 append = 1; 1625 continue; 1626 } 1627 } 1628 c += len + 1; 1629 } 1630 1631 while (t->sz + slen + 1 >= t->cap) { 1632 t->cap *= 2; 1633 if ((t->buf = realloc(t->buf, t->cap)) == NULL) 1634 err(EXIT_FAILURE, "realloc failed"); 1635 } 1636 b = t->buf; 1637 strncpy(&b[t->sz], s, slen); 1638 b[t->sz + slen] = '\0'; 1639 t->sz += slen + 1; 1640 } 1641 1642 static int 1643 lookup_string(struct section *t, const char *s) 1644 { 1645 const char *b, *c, *r; 1646 size_t len, slen; 1647 1648 slen = strlen(s); 1649 b = t->buf; 1650 for (c = b; c < b + t->sz;) { 1651 len = strlen(c); 1652 if (len >= slen) { 1653 r = c + (len - slen); 1654 if (strcmp(r, s) == 0) 1655 return (r - b); 1656 } 1657 c += len + 1; 1658 } 1659 1660 return (-1); 1661 } 1662 1663 static uint32_t crctable[256] = 1664 { 1665 0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL, 1666 0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L, 1667 0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L, 1668 0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L, 1669 0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL, 1670 0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L, 1671 0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL, 1672 0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L, 1673 0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L, 1674 0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL, 1675 0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L, 1676 0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L, 1677 0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L, 1678 0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL, 1679 0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L, 1680 0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL, 1681 0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL, 1682 0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L, 1683 0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L, 1684 0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L, 1685 0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL, 1686 0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L, 1687 0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL, 1688 0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L, 1689 0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L, 1690 0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL, 1691 0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L, 1692 0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L, 1693 0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L, 1694 0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL, 1695 0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L, 1696 0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL, 1697 0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL, 1698 0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L, 1699 0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L, 1700 0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L, 1701 0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL, 1702 0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L, 1703 0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL, 1704 0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L, 1705 0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L, 1706 0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL, 1707 0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L, 1708 0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L, 1709 0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L, 1710 0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL, 1711 0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L, 1712 0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL, 1713 0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL, 1714 0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L, 1715 0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L, 1716 0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L, 1717 0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL, 1718 0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L, 1719 0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL, 1720 0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L, 1721 0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L, 1722 0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL, 1723 0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L, 1724 0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L, 1725 0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L, 1726 0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL, 1727 0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L, 1728 0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL 1729 }; 1730 1731 static uint32_t 1732 calc_crc32(const char *p, size_t len, uint32_t crc) 1733 { 1734 uint32_t i; 1735 1736 for (i = 0; i < len; i++) { 1737 crc = crctable[(crc ^ *p++) & 0xFFL] ^ (crc >> 8); 1738 } 1739 1740 return (crc ^ 0xFFFFFFFF); 1741 } 1742