1 /* elfcomm.c -- common code for ELF format file. 2 Copyright (C) 2010-2014 Free Software Foundation, Inc. 3 4 Originally developed by Eric Youngdale <eric (at) andante.jic.com> 5 Modifications by Nick Clifton <nickc (at) 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 33 void 34 error (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 47 void 48 warn (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 61 void (*byte_put) (unsigned char *, elf_vma, int); 62 63 void 64 byte_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 93 void 94 byte_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 128 elf_vma (*byte_get) (unsigned char *, int); 129 130 elf_vma 131 byte_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 169 case 6: 170 if (sizeof (elf_vma) == 8) 171 return ((elf_vma) (field[0])) 172 | (((elf_vma) (field[1])) << 8) 173 | (((elf_vma) (field[2])) << 16) 174 | (((elf_vma) (field[3])) << 24) 175 | (((elf_vma) (field[4])) << 32) 176 | (((elf_vma) (field[5])) << 40); 177 else if (sizeof (elf_vma) == 4) 178 /* We want to extract data from an 8 byte wide field and 179 place it into a 4 byte wide field. Since this is a little 180 endian source we can just use the 4 byte extraction code. */ 181 return ((unsigned long) (field[0])) 182 | (((unsigned long) (field[1])) << 8) 183 | (((unsigned long) (field[2])) << 16) 184 | (((unsigned long) (field[3])) << 24); 185 186 case 7: 187 if (sizeof (elf_vma) == 8) 188 return ((elf_vma) (field[0])) 189 | (((elf_vma) (field[1])) << 8) 190 | (((elf_vma) (field[2])) << 16) 191 | (((elf_vma) (field[3])) << 24) 192 | (((elf_vma) (field[4])) << 32) 193 | (((elf_vma) (field[5])) << 40) 194 | (((elf_vma) (field[6])) << 48); 195 else if (sizeof (elf_vma) == 4) 196 /* We want to extract data from an 8 byte wide field and 197 place it into a 4 byte wide field. Since this is a little 198 endian source we can just use the 4 byte extraction code. */ 199 return ((unsigned long) (field[0])) 200 | (((unsigned long) (field[1])) << 8) 201 | (((unsigned long) (field[2])) << 16) 202 | (((unsigned long) (field[3])) << 24); 203 204 case 8: 205 if (sizeof (elf_vma) == 8) 206 return ((elf_vma) (field[0])) 207 | (((elf_vma) (field[1])) << 8) 208 | (((elf_vma) (field[2])) << 16) 209 | (((elf_vma) (field[3])) << 24) 210 | (((elf_vma) (field[4])) << 32) 211 | (((elf_vma) (field[5])) << 40) 212 | (((elf_vma) (field[6])) << 48) 213 | (((elf_vma) (field[7])) << 56); 214 else if (sizeof (elf_vma) == 4) 215 /* We want to extract data from an 8 byte wide field and 216 place it into a 4 byte wide field. Since this is a little 217 endian source we can just use the 4 byte extraction code. */ 218 return ((unsigned long) (field[0])) 219 | (((unsigned long) (field[1])) << 8) 220 | (((unsigned long) (field[2])) << 16) 221 | (((unsigned long) (field[3])) << 24); 222 223 default: 224 error (_("Unhandled data length: %d\n"), size); 225 abort (); 226 } 227 } 228 229 elf_vma 230 byte_get_big_endian (unsigned char *field, int size) 231 { 232 switch (size) 233 { 234 case 1: 235 return *field; 236 237 case 2: 238 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8); 239 240 case 3: 241 return ((unsigned long) (field[2])) 242 | (((unsigned long) (field[1])) << 8) 243 | (((unsigned long) (field[0])) << 16); 244 245 case 4: 246 return ((unsigned long) (field[3])) 247 | (((unsigned long) (field[2])) << 8) 248 | (((unsigned long) (field[1])) << 16) 249 | (((unsigned long) (field[0])) << 24); 250 251 case 5: 252 if (sizeof (elf_vma) == 8) 253 return ((elf_vma) (field[4])) 254 | (((elf_vma) (field[3])) << 8) 255 | (((elf_vma) (field[2])) << 16) 256 | (((elf_vma) (field[1])) << 24) 257 | (((elf_vma) (field[0])) << 32); 258 else if (sizeof (elf_vma) == 4) 259 { 260 /* Although we are extracting data from an 8 byte wide field, 261 we are returning only 4 bytes of data. */ 262 field += 1; 263 return ((unsigned long) (field[3])) 264 | (((unsigned long) (field[2])) << 8) 265 | (((unsigned long) (field[1])) << 16) 266 | (((unsigned long) (field[0])) << 24); 267 } 268 269 case 6: 270 if (sizeof (elf_vma) == 8) 271 return ((elf_vma) (field[5])) 272 | (((elf_vma) (field[4])) << 8) 273 | (((elf_vma) (field[3])) << 16) 274 | (((elf_vma) (field[2])) << 24) 275 | (((elf_vma) (field[1])) << 32) 276 | (((elf_vma) (field[0])) << 40); 277 else if (sizeof (elf_vma) == 4) 278 { 279 /* Although we are extracting data from an 8 byte wide field, 280 we are returning only 4 bytes of data. */ 281 field += 2; 282 return ((unsigned long) (field[3])) 283 | (((unsigned long) (field[2])) << 8) 284 | (((unsigned long) (field[1])) << 16) 285 | (((unsigned long) (field[0])) << 24); 286 } 287 288 case 7: 289 if (sizeof (elf_vma) == 8) 290 return ((elf_vma) (field[6])) 291 | (((elf_vma) (field[5])) << 8) 292 | (((elf_vma) (field[4])) << 16) 293 | (((elf_vma) (field[3])) << 24) 294 | (((elf_vma) (field[2])) << 32) 295 | (((elf_vma) (field[1])) << 40) 296 | (((elf_vma) (field[0])) << 48); 297 else if (sizeof (elf_vma) == 4) 298 { 299 /* Although we are extracting data from an 8 byte wide field, 300 we are returning only 4 bytes of data. */ 301 field += 3; 302 return ((unsigned long) (field[3])) 303 | (((unsigned long) (field[2])) << 8) 304 | (((unsigned long) (field[1])) << 16) 305 | (((unsigned long) (field[0])) << 24); 306 } 307 308 case 8: 309 if (sizeof (elf_vma) == 8) 310 return ((elf_vma) (field[7])) 311 | (((elf_vma) (field[6])) << 8) 312 | (((elf_vma) (field[5])) << 16) 313 | (((elf_vma) (field[4])) << 24) 314 | (((elf_vma) (field[3])) << 32) 315 | (((elf_vma) (field[2])) << 40) 316 | (((elf_vma) (field[1])) << 48) 317 | (((elf_vma) (field[0])) << 56); 318 else if (sizeof (elf_vma) == 4) 319 { 320 /* Although we are extracting data from an 8 byte wide field, 321 we are returning only 4 bytes of data. */ 322 field += 4; 323 return ((unsigned long) (field[3])) 324 | (((unsigned long) (field[2])) << 8) 325 | (((unsigned long) (field[1])) << 16) 326 | (((unsigned long) (field[0])) << 24); 327 } 328 329 default: 330 error (_("Unhandled data length: %d\n"), size); 331 abort (); 332 } 333 } 334 335 elf_vma 336 byte_get_signed (unsigned char *field, int size) 337 { 338 elf_vma x = byte_get (field, size); 339 340 switch (size) 341 { 342 case 1: 343 return (x ^ 0x80) - 0x80; 344 case 2: 345 return (x ^ 0x8000) - 0x8000; 346 case 3: 347 return (x ^ 0x800000) - 0x800000; 348 case 4: 349 return (x ^ 0x80000000) - 0x80000000; 350 case 5: 351 case 6: 352 case 7: 353 case 8: 354 /* Reads of 5-, 6-, and 7-byte numbers are the result of 355 trying to read past the end of a buffer, and will therefore 356 not have meaningful values, so we don't try to deal with 357 the sign in these cases. */ 358 return x; 359 default: 360 abort (); 361 } 362 } 363 364 /* Return the high-order 32-bits and the low-order 32-bits 365 of an 8-byte value separately. */ 366 367 void 368 byte_get_64 (unsigned char *field, elf_vma *high, elf_vma *low) 369 { 370 if (byte_get == byte_get_big_endian) 371 { 372 *high = byte_get_big_endian (field, 4); 373 *low = byte_get_big_endian (field + 4, 4); 374 } 375 else 376 { 377 *high = byte_get_little_endian (field + 4, 4); 378 *low = byte_get_little_endian (field, 4); 379 } 380 return; 381 } 382 383 /* Return the path name for a proxy entry in a thin archive, adjusted 384 relative to the path name of the thin archive itself if necessary. 385 Always returns a pointer to malloc'ed memory. */ 386 387 char * 388 adjust_relative_path (const char *file_name, const char *name, 389 int name_len) 390 { 391 char * member_file_name; 392 const char * base_name = lbasename (file_name); 393 394 /* This is a proxy entry for a thin archive member. 395 If the extended name table contains an absolute path 396 name, or if the archive is in the current directory, 397 use the path name as given. Otherwise, we need to 398 find the member relative to the directory where the 399 archive is located. */ 400 if (IS_ABSOLUTE_PATH (name) || base_name == file_name) 401 { 402 member_file_name = (char *) malloc (name_len + 1); 403 if (member_file_name == NULL) 404 { 405 error (_("Out of memory\n")); 406 return NULL; 407 } 408 memcpy (member_file_name, name, name_len); 409 member_file_name[name_len] = '\0'; 410 } 411 else 412 { 413 /* Concatenate the path components of the archive file name 414 to the relative path name from the extended name table. */ 415 size_t prefix_len = base_name - file_name; 416 member_file_name = (char *) malloc (prefix_len + name_len + 1); 417 if (member_file_name == NULL) 418 { 419 error (_("Out of memory\n")); 420 return NULL; 421 } 422 memcpy (member_file_name, file_name, prefix_len); 423 memcpy (member_file_name + prefix_len, name, name_len); 424 member_file_name[prefix_len + name_len] = '\0'; 425 } 426 return member_file_name; 427 } 428 429 /* Processes the archive index table and symbol table in ARCH. 430 Entries in the index table are SIZEOF_AR_INDEX bytes long. 431 Fills in ARCH->next_arhdr_offset and ARCH->arhdr. 432 If READ_SYMBOLS is true then fills in ARCH->index_num, ARCH->index_array, 433 ARCH->sym_size and ARCH->sym_table. 434 It is the caller's responsibility to free ARCH->index_array and 435 ARCH->sym_table. 436 Returns TRUE upon success, FALSE otherwise. 437 If failure occurs an error message is printed. */ 438 439 static bfd_boolean 440 process_archive_index_and_symbols (struct archive_info * arch, 441 unsigned int sizeof_ar_index, 442 bfd_boolean read_symbols) 443 { 444 size_t got; 445 unsigned long size; 446 447 size = strtoul (arch->arhdr.ar_size, NULL, 10); 448 size = size + (size & 1); 449 450 arch->next_arhdr_offset += sizeof arch->arhdr + size; 451 452 if (! read_symbols) 453 { 454 if (fseek (arch->file, size, SEEK_CUR) != 0) 455 { 456 error (_("%s: failed to skip archive symbol table\n"), 457 arch->file_name); 458 return FALSE; 459 } 460 } 461 else 462 { 463 unsigned long i; 464 /* A buffer used to hold numbers read in from an archive index. 465 These are always SIZEOF_AR_INDEX bytes long and stored in 466 big-endian format. */ 467 unsigned char integer_buffer[sizeof arch->index_num]; 468 unsigned char * index_buffer; 469 470 assert (sizeof_ar_index <= sizeof integer_buffer); 471 472 /* Check the size of the archive index. */ 473 if (size < sizeof_ar_index) 474 { 475 error (_("%s: the archive index is empty\n"), arch->file_name); 476 return FALSE; 477 } 478 479 /* Read the number of entries in the archive index. */ 480 got = fread (integer_buffer, 1, sizeof_ar_index, arch->file); 481 if (got != sizeof_ar_index) 482 { 483 error (_("%s: failed to read archive index\n"), arch->file_name); 484 return FALSE; 485 } 486 487 arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index); 488 size -= sizeof_ar_index; 489 490 if (size < arch->index_num * sizeof_ar_index) 491 { 492 error (_("%s: the archive index is supposed to have %ld entries of %d bytes, but the size is only %ld\n"), 493 arch->file_name, (long) arch->index_num, sizeof_ar_index, size); 494 return FALSE; 495 } 496 497 /* Read in the archive index. */ 498 index_buffer = (unsigned char *) 499 malloc (arch->index_num * sizeof_ar_index); 500 if (index_buffer == NULL) 501 { 502 error (_("Out of memory whilst trying to read archive symbol index\n")); 503 return FALSE; 504 } 505 506 got = fread (index_buffer, sizeof_ar_index, arch->index_num, arch->file); 507 if (got != arch->index_num) 508 { 509 free (index_buffer); 510 error (_("%s: failed to read archive index\n"), arch->file_name); 511 return FALSE; 512 } 513 514 size -= arch->index_num * sizeof_ar_index; 515 516 /* Convert the index numbers into the host's numeric format. */ 517 arch->index_array = (elf_vma *) 518 malloc (arch->index_num * sizeof (* arch->index_array)); 519 if (arch->index_array == NULL) 520 { 521 free (index_buffer); 522 error (_("Out of memory whilst trying to convert the archive symbol index\n")); 523 return FALSE; 524 } 525 526 for (i = 0; i < arch->index_num; i++) 527 arch->index_array[i] = 528 byte_get_big_endian ((unsigned char *) (index_buffer + (i * sizeof_ar_index)), 529 sizeof_ar_index); 530 free (index_buffer); 531 532 /* The remaining space in the header is taken up by the symbol table. */ 533 if (size < 1) 534 { 535 error (_("%s: the archive has an index but no symbols\n"), 536 arch->file_name); 537 return FALSE; 538 } 539 540 arch->sym_table = (char *) malloc (size); 541 if (arch->sym_table == NULL) 542 { 543 error (_("Out of memory whilst trying to read archive index symbol table\n")); 544 return FALSE; 545 } 546 547 arch->sym_size = size; 548 got = fread (arch->sym_table, 1, size, arch->file); 549 if (got != size) 550 { 551 error (_("%s: failed to read archive index symbol table\n"), 552 arch->file_name); 553 return FALSE; 554 } 555 } 556 557 /* Read the next archive header. */ 558 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file); 559 if (got != sizeof arch->arhdr && got != 0) 560 { 561 error (_("%s: failed to read archive header following archive index\n"), 562 arch->file_name); 563 return FALSE; 564 } 565 566 return TRUE; 567 } 568 569 /* Read the symbol table and long-name table from an archive. */ 570 571 int 572 setup_archive (struct archive_info *arch, const char *file_name, 573 FILE *file, bfd_boolean is_thin_archive, 574 bfd_boolean read_symbols) 575 { 576 size_t got; 577 578 arch->file_name = strdup (file_name); 579 arch->file = file; 580 arch->index_num = 0; 581 arch->index_array = NULL; 582 arch->sym_table = NULL; 583 arch->sym_size = 0; 584 arch->longnames = NULL; 585 arch->longnames_size = 0; 586 arch->nested_member_origin = 0; 587 arch->is_thin_archive = is_thin_archive; 588 arch->uses_64bit_indicies = FALSE; 589 arch->next_arhdr_offset = SARMAG; 590 591 /* Read the first archive member header. */ 592 if (fseek (file, SARMAG, SEEK_SET) != 0) 593 { 594 error (_("%s: failed to seek to first archive header\n"), file_name); 595 return 1; 596 } 597 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file); 598 if (got != sizeof arch->arhdr) 599 { 600 if (got == 0) 601 return 0; 602 603 error (_("%s: failed to read archive header\n"), file_name); 604 return 1; 605 } 606 607 /* See if this is the archive symbol table. */ 608 if (const_strneq (arch->arhdr.ar_name, "/ ")) 609 { 610 if (! process_archive_index_and_symbols (arch, 4, read_symbols)) 611 return 1; 612 } 613 else if (const_strneq (arch->arhdr.ar_name, "/SYM64/ ")) 614 { 615 arch->uses_64bit_indicies = TRUE; 616 if (! process_archive_index_and_symbols (arch, 8, read_symbols)) 617 return 1; 618 } 619 else if (read_symbols) 620 printf (_("%s has no archive index\n"), file_name); 621 622 if (const_strneq (arch->arhdr.ar_name, "// ")) 623 { 624 /* This is the archive string table holding long member names. */ 625 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10); 626 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size; 627 628 arch->longnames = (char *) malloc (arch->longnames_size); 629 if (arch->longnames == NULL) 630 { 631 error (_("Out of memory reading long symbol names in archive\n")); 632 return 1; 633 } 634 635 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1) 636 { 637 free (arch->longnames); 638 arch->longnames = NULL; 639 error (_("%s: failed to read long symbol name string table\n"), 640 file_name); 641 return 1; 642 } 643 644 if ((arch->longnames_size & 1) != 0) 645 getc (file); 646 } 647 648 return 0; 649 } 650 651 /* Open and setup a nested archive, if not already open. */ 652 653 int 654 setup_nested_archive (struct archive_info *nested_arch, 655 const char *member_file_name) 656 { 657 FILE * member_file; 658 659 /* Have we already setup this archive? */ 660 if (nested_arch->file_name != NULL 661 && streq (nested_arch->file_name, member_file_name)) 662 return 0; 663 664 /* Close previous file and discard cached information. */ 665 if (nested_arch->file != NULL) 666 fclose (nested_arch->file); 667 release_archive (nested_arch); 668 669 member_file = fopen (member_file_name, "rb"); 670 if (member_file == NULL) 671 return 1; 672 return setup_archive (nested_arch, member_file_name, member_file, 673 FALSE, FALSE); 674 } 675 676 /* Release the memory used for the archive information. */ 677 678 void 679 release_archive (struct archive_info * arch) 680 { 681 if (arch->file_name != NULL) 682 free (arch->file_name); 683 if (arch->index_array != NULL) 684 free (arch->index_array); 685 if (arch->sym_table != NULL) 686 free (arch->sym_table); 687 if (arch->longnames != NULL) 688 free (arch->longnames); 689 } 690 691 /* Get the name of an archive member from the current archive header. 692 For simple names, this will modify the ar_name field of the current 693 archive header. For long names, it will return a pointer to the 694 longnames table. For nested archives, it will open the nested archive 695 and get the name recursively. NESTED_ARCH is a single-entry cache so 696 we don't keep rereading the same information from a nested archive. */ 697 698 char * 699 get_archive_member_name (struct archive_info *arch, 700 struct archive_info *nested_arch) 701 { 702 unsigned long j, k; 703 704 if (arch->arhdr.ar_name[0] == '/') 705 { 706 /* We have a long name. */ 707 char *endp; 708 char *member_file_name; 709 char *member_name; 710 711 if (arch->longnames == NULL || arch->longnames_size == 0) 712 { 713 error (_("Archive member uses long names, but no longname table found\n")); 714 return NULL; 715 } 716 717 arch->nested_member_origin = 0; 718 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10); 719 if (arch->is_thin_archive && endp != NULL && * endp == ':') 720 arch->nested_member_origin = strtoul (endp + 1, NULL, 10); 721 722 while ((j < arch->longnames_size) 723 && (arch->longnames[j] != '\n') 724 && (arch->longnames[j] != '\0')) 725 j++; 726 if (arch->longnames[j-1] == '/') 727 j--; 728 arch->longnames[j] = '\0'; 729 730 if (!arch->is_thin_archive || arch->nested_member_origin == 0) 731 return arch->longnames + k; 732 733 /* This is a proxy for a member of a nested archive. 734 Find the name of the member in that archive. */ 735 member_file_name = adjust_relative_path (arch->file_name, 736 arch->longnames + k, j - k); 737 if (member_file_name != NULL 738 && setup_nested_archive (nested_arch, member_file_name) == 0) 739 { 740 member_name = get_archive_member_name_at (nested_arch, 741 arch->nested_member_origin, 742 NULL); 743 if (member_name != NULL) 744 { 745 free (member_file_name); 746 return member_name; 747 } 748 } 749 free (member_file_name); 750 751 /* Last resort: just return the name of the nested archive. */ 752 return arch->longnames + k; 753 } 754 755 /* We have a normal (short) name. */ 756 for (j = 0; j < sizeof (arch->arhdr.ar_name); j++) 757 if (arch->arhdr.ar_name[j] == '/') 758 { 759 arch->arhdr.ar_name[j] = '\0'; 760 return arch->arhdr.ar_name; 761 } 762 763 /* The full ar_name field is used. Don't rely on ar_date starting 764 with a zero byte. */ 765 { 766 char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1); 767 memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name)); 768 name[sizeof (arch->arhdr.ar_name)] = '\0'; 769 return name; 770 } 771 } 772 773 /* Get the name of an archive member at a given OFFSET within an archive 774 ARCH. */ 775 776 char * 777 get_archive_member_name_at (struct archive_info *arch, 778 unsigned long offset, 779 struct archive_info *nested_arch) 780 { 781 size_t got; 782 783 if (fseek (arch->file, offset, SEEK_SET) != 0) 784 { 785 error (_("%s: failed to seek to next file name\n"), arch->file_name); 786 return NULL; 787 } 788 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file); 789 if (got != sizeof arch->arhdr) 790 { 791 error (_("%s: failed to read archive header\n"), arch->file_name); 792 return NULL; 793 } 794 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0) 795 { 796 error (_("%s: did not find a valid archive header\n"), 797 arch->file_name); 798 return NULL; 799 } 800 801 return get_archive_member_name (arch, nested_arch); 802 } 803 804 /* Construct a string showing the name of the archive member, qualified 805 with the name of the containing archive file. For thin archives, we 806 use square brackets to denote the indirection. For nested archives, 807 we show the qualified name of the external member inside the square 808 brackets (e.g., "thin.a[normal.a(foo.o)]"). */ 809 810 char * 811 make_qualified_name (struct archive_info * arch, 812 struct archive_info * nested_arch, 813 const char *member_name) 814 { 815 const char * error_name = _("<corrupt>"); 816 size_t len; 817 char * name; 818 819 len = strlen (arch->file_name) + strlen (member_name) + 3; 820 if (arch->is_thin_archive 821 && arch->nested_member_origin != 0) 822 { 823 /* PR 15140: Allow for corrupt thin archives. */ 824 if (nested_arch->file_name) 825 len += strlen (nested_arch->file_name) + 2; 826 else 827 len += strlen (error_name) + 2; 828 } 829 830 name = (char *) malloc (len); 831 if (name == NULL) 832 { 833 error (_("Out of memory\n")); 834 return NULL; 835 } 836 837 if (arch->is_thin_archive 838 && arch->nested_member_origin != 0) 839 { 840 if (nested_arch->file_name) 841 snprintf (name, len, "%s[%s(%s)]", arch->file_name, 842 nested_arch->file_name, member_name); 843 else 844 snprintf (name, len, "%s[%s(%s)]", arch->file_name, 845 error_name, member_name); 846 } 847 else if (arch->is_thin_archive) 848 snprintf (name, len, "%s[%s]", arch->file_name, member_name); 849 else 850 snprintf (name, len, "%s(%s)", arch->file_name, member_name); 851 852 return name; 853 } 854
