1b3218649f4f798c4107b5e031438a84eb52be74
[external/binutils.git] / binutils / elfcomm.c
1 /* elfcomm.c -- common code for ELF format file.
2    Copyright (C) 2010-2016 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       /* 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
233 elf_vma
234 byte_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
343 elf_vma
344 byte_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
375 void
376 byte_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
395 char *
396 adjust_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
462 static bfd_boolean
463 process_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
604 int
605 setup_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
704 int
705 setup_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
729 void
730 release_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
749 char *
750 get_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
841 char *
842 get_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
875 char *
876 make_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 }