contrib/binutils-2.25/binutils/elfcomm.c

   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@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
  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                       unsigned long name_len)
 390 {
 391   char * member_file_name;
 392   const char * base_name = lbasename (file_name);
 393   size_t amt;
 394
 395   /* This is a proxy entry for a thin archive member.
 396      If the extended name table contains an absolute path
 397      name, or if the archive is in the current directory,
 398      use the path name as given.  Otherwise, we need to
 399      find the member relative to the directory where the
 400      archive is located.  */
 401   if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
 402     {
 403       amt = name_len + 1;
 404       if (amt == 0)
 405         return NULL;
 406       member_file_name = (char *) malloc (amt);
 407       if (member_file_name == NULL)
 408         {
 409           error (_("Out of memory\n"));
 410           return NULL;
 411         }
 412       memcpy (member_file_name, name, name_len);
 413       member_file_name[name_len] = '\0';
 414     }
 415   else
 416     {
 417       /* Concatenate the path components of the archive file name
 418          to the relative path name from the extended name table.  */
 419       size_t prefix_len = base_name - file_name;
 420
 421       amt = prefix_len + name_len + 1;
 422       /* PR 17531: file: 2896dc8b
 423          Catch wraparound.  */
 424       if (amt < prefix_len || amt < name_len)
 425         {
 426           error (_("Abnormal length of thin archive member name: %lx\n"),
 427                  name_len);
 428           return NULL;
 429         }
 430
 431       member_file_name = (char *) malloc (amt);
 432       if (member_file_name == NULL)
 433         {
 434           error (_("Out of memory\n"));
 435           return NULL;
 436         }
 437       memcpy (member_file_name, file_name, prefix_len);
 438       memcpy (member_file_name + prefix_len, name, name_len);
 439       member_file_name[prefix_len + name_len] = '\0';
 440     }
 441   return member_file_name;
 442 }
 443
 444 /* Processes the archive index table and symbol table in ARCH.
 445    Entries in the index table are SIZEOF_AR_INDEX bytes long.
 446    Fills in ARCH->next_arhdr_offset and ARCH->arhdr.
 447    If READ_SYMBOLS is true then fills in ARCH->index_num, ARCH->index_array,
 448     ARCH->sym_size and ARCH->sym_table.
 449    It is the caller's responsibility to free ARCH->index_array and
 450     ARCH->sym_table.
 451    Returns TRUE upon success, FALSE otherwise.
 452    If failure occurs an error message is printed.  */
 453
 454 static bfd_boolean
 455 process_archive_index_and_symbols (struct archive_info *  arch,
 456                                    unsigned int           sizeof_ar_index,
 457                                    bfd_boolean            read_symbols)
 458 {
 459   size_t got;
 460   unsigned long size;
 461
 462   size = strtoul (arch->arhdr.ar_size, NULL, 10);
 463   /* PR 17531: file: 912bd7de.  */
 464   if ((signed long) size < 0)
 465     {
 466       error (_("%s: invalid archive header size: %ld\n"),
 467              arch->file_name, size);
 468       return FALSE;
 469     }
 470
 471   size = size + (size & 1);
 472
 473   arch->next_arhdr_offset += sizeof arch->arhdr + size;
 474
 475   if (! read_symbols)
 476     {
 477       if (fseek (arch->file, size, SEEK_CUR) != 0)
 478         {
 479           error (_("%s: failed to skip archive symbol table\n"),
 480                  arch->file_name);
 481           return FALSE;
 482         }
 483     }
 484   else
 485     {
 486       unsigned long i;
 487       /* A buffer used to hold numbers read in from an archive index.
 488          These are always SIZEOF_AR_INDEX bytes long and stored in
 489          big-endian format.  */
 490       unsigned char integer_buffer[sizeof arch->index_num];
 491       unsigned char * index_buffer;
 492
 493       assert (sizeof_ar_index <= sizeof integer_buffer);
 494
 495       /* Check the size of the archive index.  */
 496       if (size < sizeof_ar_index)
 497         {
 498           error (_("%s: the archive index is empty\n"), arch->file_name);
 499           return FALSE;
 500         }
 501
 502       /* Read the number of entries in the archive index.  */
 503       got = fread (integer_buffer, 1, sizeof_ar_index, arch->file);
 504       if (got != sizeof_ar_index)
 505         {
 506           error (_("%s: failed to read archive index\n"), arch->file_name);
 507           return FALSE;
 508         }
 509
 510       arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index);
 511       size -= sizeof_ar_index;
 512
 513       if (size < arch->index_num * sizeof_ar_index
 514           /* PR 17531: file: 585515d1.  */
 515           || size < arch->index_num)
 516         {
 517           error (_("%s: the archive index is supposed to have 0x%lx entries of %d bytes, but the size is only 0x%lx\n"),
 518                  arch->file_name, (long) arch->index_num, sizeof_ar_index, size);
 519           return FALSE;
 520         }
 521
 522       /* Read in the archive index.  */
 523       index_buffer = (unsigned char *)
 524         malloc (arch->index_num * sizeof_ar_index);
 525       if (index_buffer == NULL)
 526         {
 527           error (_("Out of memory whilst trying to read archive symbol index\n"));
 528           return FALSE;
 529         }
 530
 531       got = fread (index_buffer, sizeof_ar_index, arch->index_num, arch->file);
 532       if (got != arch->index_num)
 533         {
 534           free (index_buffer);
 535           error (_("%s: failed to read archive index\n"), arch->file_name);
 536           return FALSE;
 537         }
 538
 539       size -= arch->index_num * sizeof_ar_index;
 540
 541       /* Convert the index numbers into the host's numeric format.  */
 542       arch->index_array = (elf_vma *)
 543         malloc (arch->index_num * sizeof (* arch->index_array));
 544       if (arch->index_array == NULL)
 545         {
 546           free (index_buffer);
 547           error (_("Out of memory whilst trying to convert the archive symbol index\n"));
 548           return FALSE;
 549         }
 550
 551       for (i = 0; i < arch->index_num; i++)
 552         arch->index_array[i] =
 553           byte_get_big_endian ((unsigned char *) (index_buffer + (i * sizeof_ar_index)),
 554                                sizeof_ar_index);
 555       free (index_buffer);
 556
 557       /* The remaining space in the header is taken up by the symbol table.  */
 558       if (size < 1)
 559         {
 560           error (_("%s: the archive has an index but no symbols\n"),
 561                  arch->file_name);
 562           return FALSE;
 563         }
 564
 565       arch->sym_table = (char *) malloc (size);
 566       if (arch->sym_table == NULL)
 567         {
 568           error (_("Out of memory whilst trying to read archive index symbol table\n"));
 569           return FALSE;
 570         }
 571
 572       arch->sym_size = size;
 573       got = fread (arch->sym_table, 1, size, arch->file);
 574       if (got != size)
 575         {
 576           error (_("%s: failed to read archive index symbol table\n"),
 577                  arch->file_name);
 578           return FALSE;
 579         }
 580     }
 581
 582   /* Read the next archive header.  */
 583   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
 584   if (got != sizeof arch->arhdr && got != 0)
 585     {
 586       error (_("%s: failed to read archive header following archive index\n"),
 587              arch->file_name);
 588       return FALSE;
 589     }
 590
 591   return TRUE;
 592 }
 593
 594 /* Read the symbol table and long-name table from an archive.  */
 595
 596 int
 597 setup_archive (struct archive_info *arch, const char *file_name,
 598                FILE *file, bfd_boolean is_thin_archive,
 599                bfd_boolean read_symbols)
 600 {
 601   size_t got;
 602
 603   arch->file_name = strdup (file_name);
 604   arch->file = file;
 605   arch->index_num = 0;
 606   arch->index_array = NULL;
 607   arch->sym_table = NULL;
 608   arch->sym_size = 0;
 609   arch->longnames = NULL;
 610   arch->longnames_size = 0;
 611   arch->nested_member_origin = 0;
 612   arch->is_thin_archive = is_thin_archive;
 613   arch->uses_64bit_indicies = FALSE;
 614   arch->next_arhdr_offset = SARMAG;
 615
 616   /* Read the first archive member header.  */
 617   if (fseek (file, SARMAG, SEEK_SET) != 0)
 618     {
 619       error (_("%s: failed to seek to first archive header\n"), file_name);
 620       return 1;
 621     }
 622   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
 623   if (got != sizeof arch->arhdr)
 624     {
 625       if (got == 0)
 626         return 0;
 627
 628       error (_("%s: failed to read archive header\n"), file_name);
 629       return 1;
 630     }
 631
 632   /* See if this is the archive symbol table.  */
 633   if (const_strneq (arch->arhdr.ar_name, "/               "))
 634     {
 635       if (! process_archive_index_and_symbols (arch, 4, read_symbols))
 636         return 1;
 637     }
 638   else if (const_strneq (arch->arhdr.ar_name, "/SYM64/         "))
 639     {
 640       arch->uses_64bit_indicies = TRUE;
 641       if (! process_archive_index_and_symbols (arch, 8, read_symbols))
 642         return 1;
 643     }
 644   else if (read_symbols)
 645     printf (_("%s has no archive index\n"), file_name);
 646
 647   if (const_strneq (arch->arhdr.ar_name, "//              "))
 648     {
 649       /* This is the archive string table holding long member names.  */
 650       arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
 651       /* PR 17531: file: 01068045.  */
 652       if (arch->longnames_size < 8)
 653         {
 654           error (_("%s: long name table is too small, (size = %ld)\n"),
 655                  file_name, arch->longnames_size);
 656           return 1;
 657         }
 658       /* PR 17531: file: 639d6a26.  */
 659       if ((signed long) arch->longnames_size < 0)
 660         {
 661           error (_("%s: long name table is too big, (size = 0x%lx)\n"),
 662                  file_name, arch->longnames_size);
 663           return 1;
 664         }
 665
 666       arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
 667
 668       /* Plus one to allow for a string terminator.  */
 669       arch->longnames = (char *) malloc (arch->longnames_size + 1);
 670       if (arch->longnames == NULL)
 671         {
 672           error (_("Out of memory reading long symbol names in archive\n"));
 673           return 1;
 674         }
 675
 676       if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
 677         {
 678           free (arch->longnames);
 679           arch->longnames = NULL;
 680           error (_("%s: failed to read long symbol name string table\n"),
 681                  file_name);
 682           return 1;
 683         }
 684
 685       if ((arch->longnames_size & 1) != 0)
 686         getc (file);
 687
 688       arch->longnames[arch->longnames_size] = 0;
 689     }
 690
 691   return 0;
 692 }
 693
 694 /* Open and setup a nested archive, if not already open.  */
 695
 696 int
 697 setup_nested_archive (struct archive_info *nested_arch,
 698                       const char *member_file_name)
 699 {
 700   FILE * member_file;
 701
 702   /* Have we already setup this archive?  */
 703   if (nested_arch->file_name != NULL
 704       && streq (nested_arch->file_name, member_file_name))
 705     return 0;
 706
 707   /* Close previous file and discard cached information.  */
 708   if (nested_arch->file != NULL)
 709     fclose (nested_arch->file);
 710   release_archive (nested_arch);
 711
 712   member_file = fopen (member_file_name, "rb");
 713   if (member_file == NULL)
 714     return 1;
 715   return setup_archive (nested_arch, member_file_name, member_file,
 716                         FALSE, FALSE);
 717 }
 718
 719 /* Release the memory used for the archive information.  */
 720
 721 void
 722 release_archive (struct archive_info * arch)
 723 {
 724   if (arch->file_name != NULL)
 725     free (arch->file_name);
 726   if (arch->index_array != NULL)
 727     free (arch->index_array);
 728   if (arch->sym_table != NULL)
 729     free (arch->sym_table);
 730   if (arch->longnames != NULL)
 731     free (arch->longnames);
 732 }
 733
 734 /* Get the name of an archive member from the current archive header.
 735    For simple names, this will modify the ar_name field of the current
 736    archive header.  For long names, it will return a pointer to the
 737    longnames table.  For nested archives, it will open the nested archive
 738    and get the name recursively.  NESTED_ARCH is a single-entry cache so
 739    we don't keep rereading the same information from a nested archive.  */
 740
 741 char *
 742 get_archive_member_name (struct archive_info *arch,
 743                          struct archive_info *nested_arch)
 744 {
 745   unsigned long j, k;
 746
 747   if (arch->arhdr.ar_name[0] == '/')
 748     {
 749       /* We have a long name.  */
 750       char *endp;
 751       char *member_file_name;
 752       char *member_name;
 753
 754       if (arch->longnames == NULL || arch->longnames_size == 0)
 755         {
 756           error (_("Archive member uses long names, but no longname table found\n"));
 757           return NULL;
 758         }
 759
 760       arch->nested_member_origin = 0;
 761       k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
 762       if (arch->is_thin_archive && endp != NULL && * endp == ':')
 763         arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
 764
 765       if (j > arch->longnames_size)
 766         {
 767           error (_("Found long name index (%ld) beyond end of long name table\n"),j);
 768           return NULL;
 769         }
 770       while ((j < arch->longnames_size)
 771              && (arch->longnames[j] != '\n')
 772              && (arch->longnames[j] != '\0'))
 773         j++;
 774       if (j > 0 && arch->longnames[j-1] == '/')
 775         j--;
 776       if (j > arch->longnames_size)
 777         j = arch->longnames_size;
 778       arch->longnames[j] = '\0';
 779
 780       if (!arch->is_thin_archive || arch->nested_member_origin == 0)
 781         return arch->longnames + k;
 782
 783       /* PR 17531: file: 2896dc8b.  */
 784       if (k >= j)
 785         {
 786           error (_("Invalid Thin archive member name\n"));
 787           return NULL;
 788         }
 789
 790       /* This is a proxy for a member of a nested archive.
 791          Find the name of the member in that archive.  */
 792       member_file_name = adjust_relative_path (arch->file_name,
 793                                                arch->longnames + k, j - k);
 794       if (member_file_name != NULL
 795           && setup_nested_archive (nested_arch, member_file_name) == 0)
 796         {
 797           member_name = get_archive_member_name_at (nested_arch,
 798                                                     arch->nested_member_origin,
 799                                                     NULL);
 800           if (member_name != NULL)
 801             {
 802               free (member_file_name);
 803               return member_name;
 804             }
 805         }
 806       free (member_file_name);
 807
 808       /* Last resort: just return the name of the nested archive.  */
 809       return arch->longnames + k;
 810     }
 811
 812   /* We have a normal (short) name.  */
 813   for (j = 0; j < sizeof (arch->arhdr.ar_name); j++)
 814     if (arch->arhdr.ar_name[j] == '/')
 815       {
 816         arch->arhdr.ar_name[j] = '\0';
 817         return arch->arhdr.ar_name;
 818       }
 819
 820   /* The full ar_name field is used.  Don't rely on ar_date starting
 821      with a zero byte.  */
 822   {
 823     char *name = xmalloc (sizeof (arch->arhdr.ar_name) + 1);
 824     memcpy (name, arch->arhdr.ar_name, sizeof (arch->arhdr.ar_name));
 825     name[sizeof (arch->arhdr.ar_name)] = '\0';
 826     return name;
 827   }
 828 }
 829
 830 /* Get the name of an archive member at a given OFFSET within an archive
 831    ARCH.  */
 832
 833 char *
 834 get_archive_member_name_at (struct archive_info *arch,
 835                             unsigned long offset,
 836                             struct archive_info *nested_arch)
 837 {
 838   size_t got;
 839
 840   if (fseek (arch->file, offset, SEEK_SET) != 0)
 841     {
 842       error (_("%s: failed to seek to next file name\n"), arch->file_name);
 843       return NULL;
 844     }
 845   got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
 846   if (got != sizeof arch->arhdr)
 847     {
 848       error (_("%s: failed to read archive header\n"), arch->file_name);
 849       return NULL;
 850     }
 851   if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
 852     {
 853       error (_("%s: did not find a valid archive header\n"),
 854              arch->file_name);
 855       return NULL;
 856     }
 857
 858   return get_archive_member_name (arch, nested_arch);
 859 }
 860
 861 /* Construct a string showing the name of the archive member, qualified
 862    with the name of the containing archive file.  For thin archives, we
 863    use square brackets to denote the indirection.  For nested archives,
 864    we show the qualified name of the external member inside the square
 865    brackets (e.g., "thin.a[normal.a(foo.o)]").  */
 866
 867 char *
 868 make_qualified_name (struct archive_info * arch,
 869                      struct archive_info * nested_arch,
 870                      const char *member_name)
 871 {
 872   const char * error_name = _("<corrupt>");
 873   size_t len;
 874   char * name;
 875
 876   len = strlen (arch->file_name) + strlen (member_name) + 3;
 877   if (arch->is_thin_archive
 878       && arch->nested_member_origin != 0)
 879     {
 880       /* PR 15140: Allow for corrupt thin archives.  */
 881       if (nested_arch->file_name)
 882         len += strlen (nested_arch->file_name) + 2;
 883       else
 884         len += strlen (error_name) + 2;
 885     }
 886
 887   name = (char *) malloc (len);
 888   if (name == NULL)
 889     {
 890       error (_("Out of memory\n"));
 891       return NULL;
 892     }
 893
 894   if (arch->is_thin_archive
 895       && arch->nested_member_origin != 0)
 896     {
 897       if (nested_arch->file_name)
 898         snprintf (name, len, "%s[%s(%s)]", arch->file_name,
 899                   nested_arch->file_name, member_name);
 900       else
 901         snprintf (name, len, "%s[%s(%s)]", arch->file_name,
 902                   error_name, member_name);
 903     }
 904   else if (arch->is_thin_archive)
 905     snprintf (name, len, "%s[%s]", arch->file_name, member_name);
 906   else
 907     snprintf (name, len, "%s(%s)", arch->file_name, member_name);
 908
 909   return name;
 910 }