<machine/stdint.h>: Check __cplusplus first.
[dragonfly.git] / contrib / binutils-2.25 / binutils / elfcomm.c
blob063662a9f7fe704a6d86cec9f954c4b21388ddf0
1 /* elfcomm.c -- common code for ELF format file.
2 Copyright (C) 2010-2014 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
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.
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.
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. */
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>
33 void
34 error (const char *message, ...)
36 va_list args;
38 /* Try to keep error messages in sync with the program's normal output. */
39 fflush (stdout);
41 va_start (args, message);
42 fprintf (stderr, _("%s: Error: "), program_name);
43 vfprintf (stderr, message, args);
44 va_end (args);
47 void
48 warn (const char *message, ...)
50 va_list args;
52 /* Try to keep warning messages in sync with the program's normal output. */
53 fflush (stdout);
55 va_start (args, message);
56 fprintf (stderr, _("%s: Warning: "), program_name);
57 vfprintf (stderr, message, args);
58 va_end (args);
61 void (*byte_put) (unsigned char *, elf_vma, int);
63 void
64 byte_put_little_endian (unsigned char * field, elf_vma value, int size)
66 switch (size)
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;
87 default:
88 error (_("Unhandled data length: %d\n"), size);
89 abort ();
93 void
94 byte_put_big_endian (unsigned char * field, elf_vma value, int size)
96 switch (size)
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;
122 default:
123 error (_("Unhandled data length: %d\n"), size);
124 abort ();
128 elf_vma (*byte_get) (unsigned char *, int);
130 elf_vma
131 byte_get_little_endian (unsigned char *field, int size)
133 switch (size)
135 case 1:
136 return *field;
138 case 2:
139 return ((unsigned int) (field[0]))
140 | (((unsigned int) (field[1])) << 8);
142 case 3:
143 return ((unsigned long) (field[0]))
144 | (((unsigned long) (field[1])) << 8)
145 | (((unsigned long) (field[2])) << 16);
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);
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);
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);
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);
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);
223 default:
224 error (_("Unhandled data length: %d\n"), size);
225 abort ();
229 elf_vma
230 byte_get_big_endian (unsigned char *field, int size)
232 switch (size)
234 case 1:
235 return *field;
237 case 2:
238 return ((unsigned int) (field[1])) | (((int) (field[0])) << 8);
240 case 3:
241 return ((unsigned long) (field[2]))
242 | (((unsigned long) (field[1])) << 8)
243 | (((unsigned long) (field[0])) << 16);
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);
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)
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);
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)
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);
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)
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);
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)
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);
329 default:
330 error (_("Unhandled data length: %d\n"), size);
331 abort ();
335 elf_vma
336 byte_get_signed (unsigned char *field, int size)
338 elf_vma x = byte_get (field, size);
340 switch (size)
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 ();
364 /* Return the high-order 32-bits and the low-order 32-bits
365 of an 8-byte value separately. */
367 void
368 byte_get_64 (unsigned char *field, elf_vma *high, elf_vma *low)
370 if (byte_get == byte_get_big_endian)
372 *high = byte_get_big_endian (field, 4);
373 *low = byte_get_big_endian (field + 4, 4);
375 else
377 *high = byte_get_little_endian (field + 4, 4);
378 *low = byte_get_little_endian (field, 4);
380 return;
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. */
387 char *
388 adjust_relative_path (const char *file_name, const char *name,
389 unsigned long name_len)
391 char * member_file_name;
392 const char * base_name = lbasename (file_name);
393 size_t amt;
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)
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)
409 error (_("Out of memory\n"));
410 return NULL;
412 memcpy (member_file_name, name, name_len);
413 member_file_name[name_len] = '\0';
415 else
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;
421 amt = prefix_len + name_len + 1;
422 /* PR 17531: file: 2896dc8b
423 Catch wraparound. */
424 if (amt < prefix_len || amt < name_len)
426 error (_("Abnormal length of thin archive member name: %lx\n"),
427 name_len);
428 return NULL;
431 member_file_name = (char *) malloc (amt);
432 if (member_file_name == NULL)
434 error (_("Out of memory\n"));
435 return NULL;
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';
441 return member_file_name;
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. */
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)
459 size_t got;
460 unsigned long size;
462 size = strtoul (arch->arhdr.ar_size, NULL, 10);
463 /* PR 17531: file: 912bd7de. */
464 if ((signed long) size < 0)
466 error (_("%s: invalid archive header size: %ld\n"),
467 arch->file_name, size);
468 return FALSE;
471 size = size + (size & 1);
473 arch->next_arhdr_offset += sizeof arch->arhdr + size;
475 if (! read_symbols)
477 if (fseek (arch->file, size, SEEK_CUR) != 0)
479 error (_("%s: failed to skip archive symbol table\n"),
480 arch->file_name);
481 return FALSE;
484 else
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;
493 assert (sizeof_ar_index <= sizeof integer_buffer);
495 /* Check the size of the archive index. */
496 if (size < sizeof_ar_index)
498 error (_("%s: the archive index is empty\n"), arch->file_name);
499 return FALSE;
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)
506 error (_("%s: failed to read archive index\n"), arch->file_name);
507 return FALSE;
510 arch->index_num = byte_get_big_endian (integer_buffer, sizeof_ar_index);
511 size -= sizeof_ar_index;
513 if (size < arch->index_num * sizeof_ar_index
514 /* PR 17531: file: 585515d1. */
515 || size < arch->index_num)
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;
522 /* Read in the archive index. */
523 index_buffer = (unsigned char *)
524 malloc (arch->index_num * sizeof_ar_index);
525 if (index_buffer == NULL)
527 error (_("Out of memory whilst trying to read archive symbol index\n"));
528 return FALSE;
531 got = fread (index_buffer, sizeof_ar_index, arch->index_num, arch->file);
532 if (got != arch->index_num)
534 free (index_buffer);
535 error (_("%s: failed to read archive index\n"), arch->file_name);
536 return FALSE;
539 size -= arch->index_num * sizeof_ar_index;
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)
546 free (index_buffer);
547 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
548 return FALSE;
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);
557 /* The remaining space in the header is taken up by the symbol table. */
558 if (size < 1)
560 error (_("%s: the archive has an index but no symbols\n"),
561 arch->file_name);
562 return FALSE;
565 arch->sym_table = (char *) malloc (size);
566 if (arch->sym_table == NULL)
568 error (_("Out of memory whilst trying to read archive index symbol table\n"));
569 return FALSE;
572 arch->sym_size = size;
573 got = fread (arch->sym_table, 1, size, arch->file);
574 if (got != size)
576 error (_("%s: failed to read archive index symbol table\n"),
577 arch->file_name);
578 return FALSE;
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)
586 error (_("%s: failed to read archive header following archive index\n"),
587 arch->file_name);
588 return FALSE;
591 return TRUE;
594 /* Read the symbol table and long-name table from an archive. */
597 setup_archive (struct archive_info *arch, const char *file_name,
598 FILE *file, bfd_boolean is_thin_archive,
599 bfd_boolean read_symbols)
601 size_t got;
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;
616 /* Read the first archive member header. */
617 if (fseek (file, SARMAG, SEEK_SET) != 0)
619 error (_("%s: failed to seek to first archive header\n"), file_name);
620 return 1;
622 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
623 if (got != sizeof arch->arhdr)
625 if (got == 0)
626 return 0;
628 error (_("%s: failed to read archive header\n"), file_name);
629 return 1;
632 /* See if this is the archive symbol table. */
633 if (const_strneq (arch->arhdr.ar_name, "/ "))
635 if (! process_archive_index_and_symbols (arch, 4, read_symbols))
636 return 1;
638 else if (const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
640 arch->uses_64bit_indicies = TRUE;
641 if (! process_archive_index_and_symbols (arch, 8, read_symbols))
642 return 1;
644 else if (read_symbols)
645 printf (_("%s has no archive index\n"), file_name);
647 if (const_strneq (arch->arhdr.ar_name, "// "))
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)
654 error (_("%s: long name table is too small, (size = %ld)\n"),
655 file_name, arch->longnames_size);
656 return 1;
658 /* PR 17531: file: 639d6a26. */
659 if ((signed long) arch->longnames_size < 0)
661 error (_("%s: long name table is too big, (size = 0x%lx)\n"),
662 file_name, arch->longnames_size);
663 return 1;
666 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
668 /* Plus one to allow for a string terminator. */
669 arch->longnames = (char *) malloc (arch->longnames_size + 1);
670 if (arch->longnames == NULL)
672 error (_("Out of memory reading long symbol names in archive\n"));
673 return 1;
676 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
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;
685 if ((arch->longnames_size & 1) != 0)
686 getc (file);
688 arch->longnames[arch->longnames_size] = 0;
691 return 0;
694 /* Open and setup a nested archive, if not already open. */
697 setup_nested_archive (struct archive_info *nested_arch,
698 const char *member_file_name)
700 FILE * member_file;
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;
707 /* Close previous file and discard cached information. */
708 if (nested_arch->file != NULL)
709 fclose (nested_arch->file);
710 release_archive (nested_arch);
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);
719 /* Release the memory used for the archive information. */
721 void
722 release_archive (struct archive_info * arch)
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);
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. */
741 char *
742 get_archive_member_name (struct archive_info *arch,
743 struct archive_info *nested_arch)
745 unsigned long j, k;
747 if (arch->arhdr.ar_name[0] == '/')
749 /* We have a long name. */
750 char *endp;
751 char *member_file_name;
752 char *member_name;
754 if (arch->longnames == NULL || arch->longnames_size == 0)
756 error (_("Archive member uses long names, but no longname table found\n"));
757 return NULL;
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);
765 if (j > arch->longnames_size)
767 error (_("Found long name index (%ld) beyond end of long name table\n"),j);
768 return NULL;
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';
780 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
781 return arch->longnames + k;
783 /* PR 17531: file: 2896dc8b. */
784 if (k >= j)
786 error (_("Invalid Thin archive member name\n"));
787 return NULL;
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)
797 member_name = get_archive_member_name_at (nested_arch,
798 arch->nested_member_origin,
799 NULL);
800 if (member_name != NULL)
802 free (member_file_name);
803 return member_name;
806 free (member_file_name);
808 /* Last resort: just return the name of the nested archive. */
809 return arch->longnames + k;
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] == '/')
816 arch->arhdr.ar_name[j] = '\0';
817 return arch->arhdr.ar_name;
820 /* The full ar_name field is used. Don't rely on ar_date starting
821 with a zero byte. */
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;
830 /* Get the name of an archive member at a given OFFSET within an archive
831 ARCH. */
833 char *
834 get_archive_member_name_at (struct archive_info *arch,
835 unsigned long offset,
836 struct archive_info *nested_arch)
838 size_t got;
840 if (fseek (arch->file, offset, SEEK_SET) != 0)
842 error (_("%s: failed to seek to next file name\n"), arch->file_name);
843 return NULL;
845 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
846 if (got != sizeof arch->arhdr)
848 error (_("%s: failed to read archive header\n"), arch->file_name);
849 return NULL;
851 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
853 error (_("%s: did not find a valid archive header\n"),
854 arch->file_name);
855 return NULL;
858 return get_archive_member_name (arch, nested_arch);
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)]"). */
867 char *
868 make_qualified_name (struct archive_info * arch,
869 struct archive_info * nested_arch,
870 const char *member_name)
872 const char * error_name = _("<corrupt>");
873 size_t len;
874 char * name;
876 len = strlen (arch->file_name) + strlen (member_name) + 3;
877 if (arch->is_thin_archive
878 && arch->nested_member_origin != 0)
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;
887 name = (char *) malloc (len);
888 if (name == NULL)
890 error (_("Out of memory\n"));
891 return NULL;
894 if (arch->is_thin_archive
895 && arch->nested_member_origin != 0)
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);
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);
909 return name;