1/* elfcomm.c -- common code for ELF format file. 2 Copyright (C) 2010-2017 Free Software Foundation, Inc. 3 4 Originally developed by Eric Youngdale <eric@andante.jic.com> 5 Modifications by Nick Clifton <nickc@redhat.com> 6 7 This file is part of GNU Binutils. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 22 02110-1301, USA. */ 23 24#include "sysdep.h" 25#include "libiberty.h" 26#include "filenames.h" 27#include "bfd.h" 28#include "aout/ar.h" 29#include "bucomm.h" 30#include "elfcomm.h" 31#include <assert.h> 32 33void 34error (const char *message, ...) 35{ 36 va_list args; 37 38 /* Try to keep error messages in sync with the program's normal output. */ 39 fflush (stdout); 40 41 va_start (args, message); 42 fprintf (stderr, _("%s: Error: "), program_name); 43 vfprintf (stderr, message, args); 44 va_end (args); 45} 46 47void 48warn (const char *message, ...) 49{ 50 va_list args; 51 52 /* Try to keep warning messages in sync with the program's normal output. */ 53 fflush (stdout); 54 55 va_start (args, message); 56 fprintf (stderr, _("%s: Warning: "), program_name); 57 vfprintf (stderr, message, args); 58 va_end (args); 59} 60 61void (*byte_put) (unsigned char *, elf_vma, int); 62 63void 64byte_put_little_endian (unsigned char * field, elf_vma value, int size) 65{ 66 switch (size) 67 { 68 case 8: 69 field[7] = (((value >> 24) >> 24) >> 8) & 0xff; 70 field[6] = ((value >> 24) >> 24) & 0xff; 71 field[5] = ((value >> 24) >> 16) & 0xff; 72 field[4] = ((value >> 24) >> 8) & 0xff; 73 /* Fall through. */ 74 case 4: 75 field[3] = (value >> 24) & 0xff; 76 /* Fall through. */ 77 case 3: 78 field[2] = (value >> 16) & 0xff; 79 /* Fall through. */ 80 case 2: 81 field[1] = (value >> 8) & 0xff; 82 /* Fall through. */ 83 case 1: 84 field[0] = value & 0xff; 85 break; 86 87 default: 88 error (_("Unhandled data length: %d\n"), size); 89 abort (); 90 } 91} 92 93void 94byte_put_big_endian (unsigned char * field, elf_vma value, int size) 95{ 96 switch (size) 97 { 98 case 8: 99 field[7] = value & 0xff; 100 field[6] = (value >> 8) & 0xff; 101 field[5] = (value >> 16) & 0xff; 102 field[4] = (value >> 24) & 0xff; 103 value >>= 16; 104 value >>= 16; 105 /* Fall through. */ 106 case 4: 107 field[3] = value & 0xff; 108 value >>= 8; 109 /* Fall through. */ 110 case 3: 111 field[2] = value & 0xff; 112 value >>= 8; 113 /* Fall through. */ 114 case 2: 115 field[1] = value & 0xff; 116 value >>= 8; 117 /* Fall through. */ 118 case 1: 119 field[0] = value & 0xff; 120 break; 121 122 default: 123 error (_("Unhandled data length: %d\n"), size); 124 abort (); 125 } 126} 127 128elf_vma (*byte_get) (unsigned char *, int); 129 130elf_vma 131byte_get_little_endian (unsigned char *field, int size) 132{ 133 switch (size) 134 { 135 case 1: 136 return *field; 137 138 case 2: 139 return ((unsigned int) (field[0])) 140 | (((unsigned int) (field[1])) << 8); 141 142 case 3: 143 return ((unsigned long) (field[0])) 144 | (((unsigned long) (field[1])) << 8) 145 | (((unsigned long) (field[2])) << 16); 146 147 case 4: 148 return ((unsigned long) (field[0])) 149 | (((unsigned long) (field[1])) << 8) 150 | (((unsigned long) (field[2])) << 16) 151 | (((unsigned long) (field[3])) << 24); 152 153 case 5: 154 if (sizeof (elf_vma) == 8) 155 return ((elf_vma) (field[0])) 156 | (((elf_vma) (field[1])) << 8) 157 | (((elf_vma) (field[2])) << 16) 158 | (((elf_vma) (field[3])) << 24) 159 | (((elf_vma) (field[4])) << 32); 160 else if (sizeof (elf_vma) == 4) 161 /* We want to extract data from an 8 byte wide field and 162 place it into a 4 byte wide field. Since this is a little 163 endian source we can just use the 4 byte extraction code. */ 164 return ((unsigned long) (field[0])) 165 | (((unsigned long) (field[1])) << 8) 166 | (((unsigned long) (field[2])) << 16) 167 | (((unsigned long) (field[3])) << 24); 168 /* Fall through. */ 169 170 case 6: 171 if (sizeof (elf_vma) == 8) 172 return ((elf_vma) (field[0])) 173 | (((elf_vma) (field[1])) << 8) 174 | (((elf_vma) (field[2])) << 16) 175 | (((elf_vma) (field[3])) << 24) 176 | (((elf_vma) (field[4])) << 32) 177 | (((elf_vma) (field[5])) << 40); 178 else if (sizeof (elf_vma) == 4) 179 /* We want to extract data from an 8 byte wide field and 180 place it into a 4 byte wide field. Since this is a little 181 endian source we can just use the 4 byte extraction code. */ 182 return ((unsigned long) (field[0])) 183 | (((unsigned long) (field[1])) << 8) 184 | (((unsigned long) (field[2])) << 16) 185 | (((unsigned long) (field[3])) << 24); 186 /* Fall through. */ 187 188 case 7: 189 if (sizeof (elf_vma) == 8) 190 return ((elf_vma) (field[0])) 191 | (((elf_vma) (field[1])) << 8) 192 | (((elf_vma) (field[2])) << 16) 193 | (((elf_vma) (field[3])) << 24) 194 | (((elf_vma) (field[4])) << 32) 195 | (((elf_vma) (field[5])) << 40) 196 | (((elf_vma) (field[6])) << 48); 197 else if (sizeof (elf_vma) == 4) 198 /* We want to extract data from an 8 byte wide field and 199 place it into a 4 byte wide field. Since this is a little 200 endian source we can just use the 4 byte extraction code. */ 201 return ((unsigned long) (field[0])) 202 | (((unsigned long) (field[1])) << 8) 203 | (((unsigned long) (field[2])) << 16) 204 | (((unsigned long) (field[3])) << 24); 205 /* Fall through. */ 206 207 case 8: 208 if (sizeof (elf_vma) == 8) 209 return ((elf_vma) (field[0])) 210 | (((elf_vma) (field[1])) << 8) 211 | (((elf_vma) (field[2])) << 16) 212 | (((elf_vma) (field[3])) << 24) 213 | (((elf_vma) (field[4])) << 32) 214 | (((elf_vma) (field[5])) << 40) 215 | (((elf_vma) (field[6])) << 48) 216 | (((elf_vma) (field[7])) << 56); 217 else if (sizeof (elf_vma) == 4) 218 /* We want to extract data from an 8 byte wide field and 219 place it into a 4 byte wide field. Since this is a little 220 endian source we can just use the 4 byte extraction code. */ 221 return ((unsigned long) (field[0])) 222 | (((unsigned long) (field[1])) << 8) 223 | (((unsigned long) (field[2])) << 16) 224 | (((unsigned long) (field[3])) << 24); 225 /* Fall through. */ 226 227 default: 228 error (_("Unhandled data length: %d\n"), size); 229 abort (); 230 } 231} 232 233elf_vma 234byte_get_big_endian (unsigned char *field, int size) 235{ 236 switch (size) 237 { 238 case 1: 239 return *field; 240 241 case 2: 242 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8); 243 244 case 3: 245 return ((unsigned long) (field[2])) 246 | (((unsigned long) (field[1])) << 8) 247 | (((unsigned long) (field[0])) << 16); 248 249 case 4: 250 return ((unsigned long) (field[3])) 251 | (((unsigned long) (field[2])) << 8) 252 | (((unsigned long) (field[1])) << 16) 253 | (((unsigned long) (field[0])) << 24); 254 255 case 5: 256 if (sizeof (elf_vma) == 8) 257 return ((elf_vma) (field[4])) 258 | (((elf_vma) (field[3])) << 8) 259 | (((elf_vma) (field[2])) << 16) 260 | (((elf_vma) (field[1])) << 24) 261 | (((elf_vma) (field[0])) << 32); 262 else if (sizeof (elf_vma) == 4) 263 { 264 /* Although we are extracting data from an 8 byte wide field, 265 we are returning only 4 bytes of data. */ 266 field += 1; 267 return ((unsigned long) (field[3])) 268 | (((unsigned long) (field[2])) << 8) 269 | (((unsigned long) (field[1])) << 16) 270 | (((unsigned long) (field[0])) << 24); 271 } 272 /* Fall through. */ 273 274 case 6: 275 if (sizeof (elf_vma) == 8) 276 return ((elf_vma) (field[5])) 277 | (((elf_vma) (field[4])) << 8) 278 | (((elf_vma) (field[3])) << 16) 279 | (((elf_vma) (field[2])) << 24) 280 | (((elf_vma) (field[1])) << 32) 281 | (((elf_vma) (field[0])) << 40); 282 else if (sizeof (elf_vma) == 4) 283 { 284 /* Although we are extracting data from an 8 byte wide field, 285 we are returning only 4 bytes of data. */ 286 field += 2; 287 return ((unsigned long) (field[3])) 288 | (((unsigned long) (field[2])) << 8) 289 | (((unsigned long) (field[1])) << 16) 290 | (((unsigned long) (field[0])) << 24); 291 } 292 /* Fall through. */ 293 294 case 7: 295 if (sizeof (elf_vma) == 8) 296 return ((elf_vma) (field[6])) 297 | (((elf_vma) (field[5])) << 8) 298 | (((elf_vma) (field[4])) << 16) 299 | (((elf_vma) (field[3])) << 24) 300 | (((elf_vma) (field[2])) << 32) 301 | (((elf_vma) (field[1])) << 40) 302 | (((elf_vma) (field[0])) << 48); 303 else if (sizeof (elf_vma) == 4) 304 { 305 /* Although we are extracting data from an 8 byte wide field, 306 we are returning only 4 bytes of data. */ 307 field += 3; 308 return ((unsigned long) (field[3])) 309 | (((unsigned long) (field[2])) << 8) 310 | (((unsigned long) (field[1])) << 16) 311 | (((unsigned long) (field[0])) << 24); 312 } 313 /* Fall through. */ 314 315 case 8: 316 if (sizeof (elf_vma) == 8) 317 return ((elf_vma) (field[7])) 318 | (((elf_vma) (field[6])) << 8) 319 | (((elf_vma) (field[5])) << 16) 320 | (((elf_vma) (field[4])) << 24) 321 | (((elf_vma) (field[3])) << 32) 322 | (((elf_vma) (field[2])) << 40) 323 | (((elf_vma) (field[1])) << 48) 324 | (((elf_vma) (field[0])) << 56); 325 else if (sizeof (elf_vma) == 4) 326 { 327 /* Although we are extracting data from an 8 byte wide field, 328 we are returning only 4 bytes of data. */ 329 field += 4; 330 return ((unsigned long) (field[3])) 331 | (((unsigned long) (field[2])) << 8) 332 | (((unsigned long) (field[1])) << 16) 333 | (((unsigned long) (field[0])) << 24); 334 } 335 /* Fall through. */ 336 337 default: 338 error (_("Unhandled data length: %d\n"), size); 339 abort (); 340 } 341} 342 343elf_vma 344byte_get_signed (unsigned char *field, int size) 345{ 346 elf_vma x = byte_get (field, size); 347 348 switch (size) 349 { 350 case 1: 351 return (x ^ 0x80) - 0x80; 352 case 2: 353 return (x ^ 0x8000) - 0x8000; 354 case 3: 355 return (x ^ 0x800000) - 0x800000; 356 case 4: 357 return (x ^ 0x80000000) - 0x80000000; 358 case 5: 359 case 6: 360 case 7: 361 case 8: 362 /* Reads of 5-, 6-, and 7-byte numbers are the result of 363 trying to read past the end of a buffer, and will therefore 364 not have meaningful values, so we don't try to deal with 365 the sign in these cases. */ 366 return x; 367 default: 368 abort (); 369 } 370} 371 372/* Return the high-order 32-bits and the low-order 32-bits 373 of an 8-byte value separately. */ 374 375void 376byte_get_64 (unsigned char *field, elf_vma *high, elf_vma *low) 377{ 378 if (byte_get == byte_get_big_endian) 379 { 380 *high = byte_get_big_endian (field, 4); 381 *low = byte_get_big_endian (field + 4, 4); 382 } 383 else 384 { 385 *high = byte_get_little_endian (field + 4, 4); 386 *low = byte_get_little_endian (field, 4); 387 } 388 return; 389} 390 391/* Return the path name for a proxy entry in a thin archive, adjusted 392 relative to the path name of the thin archive itself if necessary. 393 Always returns a pointer to malloc'ed memory. */ 394 395char * 396adjust_relative_path (const char *file_name, const char *name, 397 unsigned long name_len) 398{ 399 char * member_file_name; 400 const char * base_name = lbasename (file_name); 401 size_t amt; 402 403 /* This is a proxy entry for a thin archive member. 404 If the extended name table contains an absolute path 405 name, or if the archive is in the current directory, 406 use the path name as given. Otherwise, we need to 407 find the member relative to the directory where the 408 archive is located. */ 409 if (IS_ABSOLUTE_PATH (name) || base_name == file_name) 410 { 411 amt = name_len + 1; 412 if (amt == 0) 413 return NULL; 414 member_file_name = (char *) malloc (amt); 415 if (member_file_name == NULL) 416 { 417 error (_("Out of memory\n")); 418 return NULL; 419 } 420 memcpy (member_file_name, name, name_len); 421 member_file_name[name_len] = '\0'; 422 } 423 else 424 { 425 /* Concatenate the path components of the archive file name 426 to the relative path name from the extended name table. */ 427 size_t prefix_len = base_name - file_name; 428 429 amt = prefix_len + name_len + 1; 430 /* PR 17531: file: 2896dc8b 431 Catch wraparound. */ 432 if (amt < prefix_len || amt < name_len) 433 { 434 error (_("Abnormal length of thin archive member name: %lx\n"), 435 name_len); 436 return NULL; 437 } 438 439 member_file_name = (char *) malloc (amt); 440 if (member_file_name == NULL) 441 { 442 error (_("Out of memory\n")); 443 return NULL; 444 } 445 memcpy (member_file_name, file_name, prefix_len); 446 memcpy (member_file_name + prefix_len, name, name_len); 447 member_file_name[prefix_len + name_len] = '\0'; 448 } 449 return member_file_name; 450} 451 452/* Processes the archive index table and symbol table in ARCH. 453 Entries in the index table are SIZEOF_AR_INDEX bytes long. 454 Fills in ARCH->next_arhdr_offset and ARCH->arhdr. 455 If READ_SYMBOLS is true then fills in ARCH->index_num, ARCH->index_array, 456 ARCH->sym_size and ARCH->sym_table. 457 It is the caller's responsibility to free ARCH->index_array and 458 ARCH->sym_table. 459 Returns TRUE upon success, FALSE otherwise. 460 If failure occurs an error message is printed. */ 461 462static bfd_boolean 463process_archive_index_and_symbols (struct archive_info * arch, 464 unsigned int sizeof_ar_index, 465 bfd_boolean read_symbols) 466{ 467 size_t got; 468 unsigned long size; 469 470 size = strtoul (arch->arhdr.ar_size, NULL, 10); 471 /* PR 17531: file: 912bd7de. */ 472 if ((signed long) size < 0) 473 { 474 error (_("%s: invalid archive header size: %ld\n"), 475 arch->file_name, size); 476 return FALSE; 477 } 478 479 size = size + (size & 1); 480 481 arch->next_arhdr_offset += sizeof arch->arhdr + size; 482 483 if (! read_symbols) 484 { 485 if (fseek (arch->file, size, SEEK_CUR) != 0) 486 { 487 error (_("%s: failed to skip archive symbol table\n"), 488 arch->file_name); 489 return FALSE; 490 } 491 } 492 else 493 { 494 unsigned long i; 495 /* A buffer used to hold numbers read in from an archive index. 496 These are always SIZEOF_AR_INDEX bytes long and stored in 497 big-endian format. */ 498 unsigned char integer_buffer[sizeof arch->index_num]; 499 unsigned char * index_buffer; 500 501 assert (sizeof_ar_index <= sizeof integer_buffer); 502 503 /* Check the size of the archive index. */ 504 if (size < sizeof_ar_index) 505 { 506 error (_("%s: the archive index is empty\n"), arch->file_name); 507 return FALSE; 508 } 509 510 /* Read the number of entries in the archive index. */ 511 got = fread (integer_buffer, 1, sizeof_ar_index, arch->file); 512 if (got != sizeof_ar_index) 513 { 514 error (_("%s: failed to read archive index\n"), arch->file_name); 515 return FALSE; 516 } 517 518 arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index); 519 size -= sizeof_ar_index; 520 521 if (size < arch->index_num * sizeof_ar_index 522 /* PR 17531: file: 585515d1. */ 523 || size < arch->index_num) 524 { 525 error (_("%s: the archive index is supposed to have 0x%lx entries of %d bytes, but the size is only 0x%lx\n"), 526 arch->file_name, (long) arch->index_num, sizeof_ar_index, size); 527 return FALSE; 528 } 529 530 /* Read in the archive index. */ 531 index_buffer = (unsigned char *) 532 malloc (arch->index_num * sizeof_ar_index); 533 if (index_buffer == NULL) 534 { 535 error (_("Out of memory whilst trying to read archive symbol index\n")); 536 return FALSE; 537 } 538 539 got = fread (index_buffer, sizeof_ar_index, arch->index_num, arch->file); 540 if (got != arch->index_num) 541 { 542 free (index_buffer); 543 error (_("%s: failed to read archive index\n"), arch->file_name); 544 return FALSE; 545 } 546 547 size -= arch->index_num * sizeof_ar_index; 548 549 /* Convert the index numbers into the host's numeric format. */ 550 arch->index_array = (elf_vma *) 551 malloc (arch->index_num * sizeof (* arch->index_array)); 552 if (arch->index_array == NULL) 553 { 554 free (index_buffer); 555 error (_("Out of memory whilst trying to convert the archive symbol index\n")); 556 return FALSE; 557 } 558 559 for (i = 0; i < arch->index_num; i++) 560 arch->index_array[i] = 561 byte_get_big_endian ((unsigned char *) (index_buffer + (i * sizeof_ar_index)), 562 sizeof_ar_index); 563 free (index_buffer); 564 565 /* The remaining space in the header is taken up by the symbol table. */ 566 if (size < 1) 567 { 568 error (_("%s: the archive has an index but no symbols\n"), 569 arch->file_name); 570 return FALSE; 571 } 572 573 arch->sym_table = (char *) malloc (size); 574 if (arch->sym_table == NULL) 575 { 576 error (_("Out of memory whilst trying to read archive index symbol table\n")); 577 return FALSE; 578 } 579 580 arch->sym_size = size; 581 got = fread (arch->sym_table, 1, size, arch->file); 582 if (got != size) 583 { 584 error (_("%s: failed to read archive index symbol table\n"), 585 arch->file_name); 586 return FALSE; 587 } 588 } 589 590 /* Read the next archive header. */ 591 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file); 592 if (got != sizeof arch->arhdr && got != 0) 593 { 594 error (_("%s: failed to read archive header following archive index\n"), 595 arch->file_name); 596 return FALSE; 597 } 598 599 return TRUE; 600} 601 602/* Read the symbol table and long-name table from an archive. */ 603 604int 605setup_archive (struct archive_info *arch, const char *file_name, 606 FILE *file, bfd_boolean is_thin_archive, 607 bfd_boolean read_symbols) 608{ 609 size_t got; 610 611 arch->file_name = strdup (file_name); 612 arch->file = file; 613 arch->index_num = 0; 614 arch->index_array = NULL; 615 arch->sym_table = NULL; 616 arch->sym_size = 0; 617 arch->longnames = NULL; 618 arch->longnames_size = 0; 619 arch->nested_member_origin = 0; 620 arch->is_thin_archive = is_thin_archive; 621 arch->uses_64bit_indicies = FALSE; 622 arch->next_arhdr_offset = SARMAG; 623 624 /* Read the first archive member header. */ 625 if (fseek (file, SARMAG, SEEK_SET) != 0) 626 { 627 error (_("%s: failed to seek to first archive header\n"), file_name); 628 return 1; 629 } 630 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file); 631 if (got != sizeof arch->arhdr) 632 { 633 if (got == 0) 634 return 0; 635 636 error (_("%s: failed to read archive header\n"), file_name); 637 return 1; 638 } 639 640 /* See if this is the archive symbol table. */ 641 if (const_strneq (arch->arhdr.ar_name, "/ ")) 642 { 643 if (! process_archive_index_and_symbols (arch, 4, read_symbols)) 644 return 1; 645 } 646 else if (const_strneq (arch->arhdr.ar_name, "/SYM64/ ")) 647 { 648 arch->uses_64bit_indicies = TRUE; 649 if (! process_archive_index_and_symbols (arch, 8, read_symbols)) 650 return 1; 651 } 652 else if (read_symbols) 653 printf (_("%s has no archive index\n"), file_name); 654 655 if (const_strneq (arch->arhdr.ar_name, "// ")) 656 { 657 /* This is the archive string table holding long member names. */ 658 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10); 659 /* PR 17531: file: 01068045. */ 660 if (arch->longnames_size < 8) 661 { 662 error (_("%s: long name table is too small, (size = %ld)\n"), 663 file_name, arch->longnames_size); 664 return 1; 665 } 666 /* PR 17531: file: 639d6a26. */ 667 if ((signed long) arch->longnames_size < 0) 668 { 669 error (_("%s: long name table is too big, (size = 0x%lx)\n"), 670 file_name, arch->longnames_size); 671 return 1; 672 } 673 674 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size; 675 676 /* Plus one to allow for a string terminator. */ 677 arch->longnames = (char *) malloc (arch->longnames_size + 1); 678 if (arch->longnames == NULL) 679 { 680 error (_("Out of memory reading long symbol names in archive\n")); 681 return 1; 682 } 683 684 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1) 685 { 686 free (arch->longnames); 687 arch->longnames = NULL; 688 error (_("%s: failed to read long symbol name string table\n"), 689 file_name); 690 return 1; 691 } 692 693 if ((arch->longnames_size & 1) != 0) 694 getc (file); 695 696 arch->longnames[arch->longnames_size] = 0; 697 } 698 699 return 0; 700} 701 702/* Open and setup a nested archive, if not already open. */ 703 704int 705setup_nested_archive (struct archive_info *nested_arch, 706 const char *member_file_name) 707{ 708 FILE * member_file; 709 710 /* Have we already setup this archive? */ 711 if (nested_arch->file_name != NULL 712 && streq (nested_arch->file_name, member_file_name)) 713 return 0; 714 715 /* Close previous file and discard cached information. */ 716 if (nested_arch->file != NULL) 717 fclose (nested_arch->file); 718 release_archive (nested_arch); 719 720 member_file = fopen (member_file_name, "rb"); 721 if (member_file == NULL) 722 return 1; 723 return setup_archive (nested_arch, member_file_name, member_file, 724 FALSE, FALSE); 725} 726 727/* Release the memory used for the archive information. */ 728 729void 730release_archive (struct archive_info * arch) 731{ 732 if (arch->file_name != NULL) 733 free (arch->file_name); 734 if (arch->index_array != NULL) 735 free (arch->index_array); 736 if (arch->sym_table != NULL) 737 free (arch->sym_table); 738 if (arch->longnames != NULL) 739 free (arch->longnames); 740} 741 742/* Get the name of an archive member from the current archive header. 743 For simple names, this will modify the ar_name field of the current 744 archive header. For long names, it will return a pointer to the 745 longnames table. For nested archives, it will open the nested archive 746 and get the name recursively. NESTED_ARCH is a single-entry cache so 747 we don't keep rereading the same information from a nested archive. */ 748 749char * 750get_archive_member_name (struct archive_info *arch, 751 struct archive_info *nested_arch) 752{ 753 unsigned long j, k; 754 755 if (arch->arhdr.ar_name[0] == '/') 756 { 757 /* We have a long name. */ 758 char *endp; 759 char *member_file_name; 760 char *member_name; 761 762 if (arch->longnames == NULL || arch->longnames_size == 0) 763 { 764 error (_("Archive member uses long names, but no longname table found\n")); 765 return NULL; 766 } 767 768 arch->nested_member_origin = 0; 769 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10); 770 if (arch->is_thin_archive && endp != NULL && * endp == ':') 771 arch->nested_member_origin = strtoul (endp + 1, NULL, 10); 772 773 if (j > arch->longnames_size) 774 { 775 error (_("Found long name index (%ld) beyond end of long name table\n"),j); 776 return NULL; 777 } 778 while ((j < arch->longnames_size) 779 && (arch->longnames[j] != '\n') 780 && (arch->longnames[j] != '\0')) 781 j++; 782 if (j > 0 && arch->longnames[j-1] == '/') 783 j--; 784 if (j > arch->longnames_size) 785 j = arch->longnames_size; 786 arch->longnames[j] = '\0'; 787 788 if (!arch->is_thin_archive || arch->nested_member_origin == 0) 789 return arch->longnames + k; 790 791 /* PR 17531: file: 2896dc8b. */ 792 if (k >= j) 793 { 794 error (_("Invalid Thin archive member name\n")); 795 return NULL; 796 } 797 798 /* This is a proxy for a member of a nested archive. 799 Find the name of the member in that archive. */ 800 member_file_name = adjust_relative_path (arch->file_name, 801 arch->longnames + k, j - k); 802 if (member_file_name != NULL 803 && setup_nested_archive (nested_arch, member_file_name) == 0) 804 { 805 member_name = get_archive_member_name_at (nested_arch, 806 arch->nested_member_origin, 807 NULL); 808 if (member_name != NULL) 809 { 810 free (member_file_name); 811 return member_name; 812 } 813 } 814 free (member_file_name); 815 816 /* Last resort: just return the name of the nested archive. */ 817 return arch->longnames + k; 818 } 819 820 /* We have a normal (short) name. */ 821 for (j = 0; j < sizeof (arch->arhdr.ar_name); j++) 822 if (arch->arhdr.ar_name[j] == '/') 823 { 824 arch->arhdr.ar_name[j] = '\0'; 825 return arch->arhdr.ar_name; 826 } 827 828 /* The full ar_name field is used. Don't rely on ar_date starting 829 with a zero byte. */ 830 { 831 char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1); 832 memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name)); 833 name[sizeof (arch->arhdr.ar_name)] = '\0'; 834 return name; 835 } 836} 837 838/* Get the name of an archive member at a given OFFSET within an archive 839 ARCH. */ 840 841char * 842get_archive_member_name_at (struct archive_info *arch, 843 unsigned long offset, 844 struct archive_info *nested_arch) 845{ 846 size_t got; 847 848 if (fseek (arch->file, offset, SEEK_SET) != 0) 849 { 850 error (_("%s: failed to seek to next file name\n"), arch->file_name); 851 return NULL; 852 } 853 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file); 854 if (got != sizeof arch->arhdr) 855 { 856 error (_("%s: failed to read archive header\n"), arch->file_name); 857 return NULL; 858 } 859 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0) 860 { 861 error (_("%s: did not find a valid archive header\n"), 862 arch->file_name); 863 return NULL; 864 } 865 866 return get_archive_member_name (arch, nested_arch); 867} 868 869/* Construct a string showing the name of the archive member, qualified 870 with the name of the containing archive file. For thin archives, we 871 use square brackets to denote the indirection. For nested archives, 872 we show the qualified name of the external member inside the square 873 brackets (e.g., "thin.a[normal.a(foo.o)]"). */ 874 875char * 876make_qualified_name (struct archive_info * arch, 877 struct archive_info * nested_arch, 878 const char *member_name) 879{ 880 const char * error_name = _("<corrupt>"); 881 size_t len; 882 char * name; 883 884 len = strlen (arch->file_name) + strlen (member_name) + 3; 885 if (arch->is_thin_archive 886 && arch->nested_member_origin != 0) 887 { 888 /* PR 15140: Allow for corrupt thin archives. */ 889 if (nested_arch->file_name) 890 len += strlen (nested_arch->file_name) + 2; 891 else 892 len += strlen (error_name) + 2; 893 } 894 895 name = (char *) malloc (len); 896 if (name == NULL) 897 { 898 error (_("Out of memory\n")); 899 return NULL; 900 } 901 902 if (arch->is_thin_archive 903 && arch->nested_member_origin != 0) 904 { 905 if (nested_arch->file_name) 906 snprintf (name, len, "%s[%s(%s)]", arch->file_name, 907 nested_arch->file_name, member_name); 908 else 909 snprintf (name, len, "%s[%s(%s)]", arch->file_name, 910 error_name, member_name); 911 } 912 else if (arch->is_thin_archive) 913 snprintf (name, len, "%s[%s]", arch->file_name, member_name); 914 else 915 snprintf (name, len, "%s(%s)", arch->file_name, member_name); 916 917 return name; 918} 919