1/* Create descriptor for processing file.
2   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Red Hat, Inc.
3   Written by Ulrich Drepper <drepper@redhat.com>, 1998.
4
5   This program is free software; you can redistribute it and/or modify
6   it under the terms of the GNU General Public License as published by
7   the Free Software Foundation, version 2.
8
9   This program is distributed in the hope that it will be useful,
10   but WITHOUT ANY WARRANTY; without even the implied warranty of
11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12   GNU General Public License for more details.
13
14   You should have received a copy of the GNU General Public License
15   along with this program; if not, write to the Free Software Foundation,
16   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
17
18#ifdef HAVE_CONFIG_H
19# include <config.h>
20#endif
21
22#include <assert.h>
23#include <ctype.h>
24#include <errno.h>
25#include <fcntl.h>
26#include <stdbool.h>
27#include <stddef.h>
28#include <string.h>
29#include <unistd.h>
30#include <sys/mman.h>
31#include <sys/param.h>
32#include <sys/stat.h>
33
34#include "libelfP.h"
35#include "common.h"
36
37
38/* Create descriptor for archive in memory.  */
39static inline Elf *
40file_read_ar (int fildes, void *map_address, off_t offset, size_t maxsize,
41	      Elf_Cmd cmd, Elf *parent)
42{
43  Elf *elf;
44
45  /* Create a descriptor.  */
46  elf = allocate_elf (fildes, map_address, offset, maxsize, cmd, parent,
47                      ELF_K_AR, 0);
48  if (elf != NULL)
49    {
50      /* We don't read all the symbol tables in advance.  All this will
51	 happen on demand.  */
52      elf->state.ar.offset = offset + SARMAG;
53
54      elf->state.ar.elf_ar_hdr.ar_rawname = elf->state.ar.raw_name;
55    }
56
57  return elf;
58}
59
60
61static size_t
62get_shnum (void *map_address, unsigned char *e_ident, int fildes, off_t offset,
63	   size_t maxsize)
64{
65  size_t result;
66  union
67  {
68    Elf32_Ehdr *e32;
69    Elf64_Ehdr *e64;
70    void *p;
71  } ehdr;
72  bool is32 = e_ident[EI_CLASS] == ELFCLASS32;
73
74  /* Make the ELF header available.  */
75  if (likely (map_address != NULL) && e_ident[EI_DATA] == MY_ELFDATA
76      && (ALLOW_UNALIGNED
77	  || (((size_t) ((char *) map_address + offset))
78	      & ((is32 ? __alignof__ (Elf32_Ehdr) : __alignof__ (Elf64_Ehdr))
79		 - 1)) == 0))
80    ehdr.p = (char *) map_address + offset;
81  else
82    {
83      /* We have to read the data from the file.  */
84      size_t len = is32 ? sizeof (Elf32_Ehdr) : sizeof (Elf64_Ehdr);
85
86      ehdr.p = alloca (len);
87      /* Fill it.  */
88      if ((size_t) pread (fildes, ehdr.p, len, offset) != len)
89	/* Failed reading.  */
90	return (size_t) -1l;
91
92      if (e_ident[EI_DATA] != MY_ELFDATA)
93	{
94	  if (is32)
95	    {
96	      CONVERT (ehdr.e32->e_shnum);
97	      CONVERT (ehdr.e32->e_shoff);
98	    }
99	  else
100	    {
101	      CONVERT (ehdr.e64->e_shnum);
102	      CONVERT (ehdr.e64->e_shoff);
103	    }
104	}
105    }
106
107  if (is32)
108    {
109      /* Get the number of sections from the ELF header.  */
110      result = ehdr.e32->e_shnum;
111
112      if (unlikely (result == 0) && ehdr.e32->e_shoff != 0)
113	{
114	  if (offset + ehdr.e32->e_shoff + sizeof (Elf32_Shdr) > maxsize)
115	    /* Cannot read the first section header.  */
116	    return (size_t) -1l;
117
118	  if (likely (map_address != NULL) && e_ident[EI_DATA] == MY_ELFDATA
119	      && (ALLOW_UNALIGNED
120		  || (((size_t) ((char *) map_address + offset))
121		      & (__alignof__ (Elf32_Ehdr) - 1)) == 0))
122	    /* We can directly access the memory.  */
123	    result = ((Elf32_Shdr *) ((char *) map_address
124				      + ehdr.e32->e_shoff
125				      + offset))->sh_size;
126	  else
127	    {
128	      Elf32_Word size;
129
130	      if (pread (fildes, &size, sizeof (Elf32_Word),
131			 offset + ehdr.e32->e_shoff
132			 + offsetof (Elf32_Shdr, sh_size))
133		  != sizeof (Elf32_Word))
134		return (size_t) -1l;
135
136	      if (e_ident[EI_DATA] != MY_ELFDATA)
137		CONVERT (size);
138
139	      result = size;
140	    }
141	}
142    }
143  else
144    {
145      /* Get the number of sections from the ELF header.  */
146      result = ehdr.e64->e_shnum;
147
148      if (unlikely (result == 0) && ehdr.e64->e_shoff != 0)
149	{
150	  if (offset + ehdr.e64->e_shoff + sizeof (Elf64_Shdr) > maxsize)
151	    /* Cannot read the first section header.  */
152	    return (size_t) -1l;
153
154	  if (likely (map_address != NULL) && e_ident[EI_DATA] == MY_ELFDATA
155	      && (ALLOW_UNALIGNED
156		  || (((size_t) ((char *) map_address + offset))
157		      & (__alignof__ (Elf64_Ehdr) - 1)) == 0))
158	    /* We can directly access the memory.  */
159	    result = ((Elf64_Shdr *) ((char *) map_address
160				      + ehdr.e64->e_shoff
161				      + offset))->sh_size;
162	  else
163	    {
164	      Elf64_Word size;
165
166	      if (pread (fildes, &size, sizeof (Elf64_Word),
167			 offset + ehdr.e64->e_shoff
168			 + offsetof (Elf64_Shdr, sh_size))
169		  != sizeof (Elf64_Word))
170		return (size_t) -1l;
171
172	      if (e_ident[EI_DATA] != MY_ELFDATA)
173		CONVERT (size);
174
175	      result = size;
176	    }
177	}
178    }
179
180  return result;
181}
182
183
184/* Create descriptor for ELF file in memory.  */
185static Elf *
186file_read_elf (int fildes, void *map_address, off_t offset, size_t maxsize,
187	       Elf_Cmd cmd, Elf *parent)
188{
189  /* We only read the ELF header now.  */
190  unsigned char *e_ident;
191  size_t scncnt;
192  Elf *elf;
193
194  if (map_address != NULL)
195    /* It's right at the beginning of the file.  No word access
196       required, just bytes.  */
197    e_ident = (unsigned char *) map_address + offset;
198  else
199    {
200      e_ident = (unsigned char *) alloca (EI_NIDENT);
201
202      if (pread (fildes, e_ident, EI_NIDENT, offset) != EI_NIDENT)
203	{
204	  __libelf_seterrno (ELF_E_READ_ERROR);
205	  return NULL;
206	}
207    }
208
209  /* Verify the binary is of the class we can handle.  */
210  if ((e_ident[EI_CLASS] != ELFCLASS32
211       && e_ident[EI_CLASS] != ELFCLASS64)
212      /* We also can only handle two encodings.  */
213      || (e_ident[EI_DATA] != ELFDATA2LSB
214	  && e_ident[EI_DATA] != ELFDATA2MSB))
215    {
216      /* Cannot handle this.  */
217      __libelf_seterrno (ELF_E_INVALID_FILE);
218      return NULL;
219    }
220
221  /* Determine the number of sections.  */
222  scncnt = get_shnum (map_address, e_ident, fildes, offset, maxsize);
223  if (scncnt == (size_t) -1l)
224    /* Could not determine the number of sections.  */
225    return NULL;
226
227  /* We can now allocate the memory.  */
228  elf = allocate_elf (fildes, map_address, offset, maxsize, cmd, parent,
229		      ELF_K_ELF, scncnt * sizeof (Elf_Scn));
230  if (elf == NULL)
231    /* Not enough memory.  */
232    return NULL;
233
234  /* Some more or less arbitrary value.  */
235  elf->state.elf.scnincr = 10;
236
237  if (e_ident[EI_CLASS] == ELFCLASS32)
238    {
239      /* This pointer might not be directly usable if the alignment is
240	 not sufficient for the architecture.  */
241      Elf32_Ehdr *ehdr = (Elf32_Ehdr *) ((char *) map_address + offset);
242      size_t cnt;
243
244      assert ((unsigned int) scncnt == scncnt);
245      elf->state.elf32.scns.cnt = elf->state.elf32.scns.max = scncnt;
246
247      /* This is a 32-bit binary.  */
248      if (map_address != NULL && e_ident[EI_DATA] == MY_ELFDATA
249	  && (ALLOW_UNALIGNED
250	      || ((((uintptr_t) ehdr) & (__alignof__ (Elf32_Ehdr) - 1)) == 0
251		  && ((uintptr_t) ((char *) ehdr + ehdr->e_shoff)
252		      & (__alignof__ (Elf32_Shdr) - 1)) == 0
253		  && ((uintptr_t) ((char *) ehdr + ehdr->e_phoff)
254		      & (__alignof__ (Elf32_Phdr) - 1)) == 0)))
255	{
256	  /* We can use the mmapped memory.  */
257	  elf->state.elf32.ehdr =
258	    (Elf32_Ehdr *) ((char *) map_address + offset);
259	  elf->state.elf32.shdr =
260	    (Elf32_Shdr *) ((char *) map_address + offset
261			    + elf->state.elf32.ehdr->e_shoff);
262	  if (elf->state.elf32.ehdr->e_phnum)
263	    /* Assign a value only if there really is a program
264	       header.  Otherwise the value remains NULL.  */
265	    elf->state.elf32.phdr
266	      = (Elf32_Phdr *) ((char *) map_address + offset
267				+ elf->state.elf32.ehdr->e_phoff);
268
269	  for (cnt = 0; cnt < scncnt; ++cnt)
270	    {
271	      elf->state.elf32.scns.data[cnt].index = cnt;
272	      elf->state.elf32.scns.data[cnt].elf = elf;
273	      elf->state.elf32.scns.data[cnt].shdr.e32 =
274		&elf->state.elf32.shdr[cnt];
275	      elf->state.elf32.scns.data[cnt].rawdata_base =
276		elf->state.elf32.scns.data[cnt].data_base =
277		((char *) map_address + offset
278		 + elf->state.elf32.shdr[cnt].sh_offset);
279	      elf->state.elf32.scns.data[cnt].list = &elf->state.elf32.scns;
280	    }
281	}
282      else
283	{
284	  /* Read the data.  */
285	  if (pread (elf->fildes, &elf->state.elf32.ehdr_mem,
286		     sizeof (Elf32_Ehdr), offset) != sizeof (Elf32_Ehdr))
287	    {
288	      /* We must be able to read the ELF header.  */
289	      __libelf_seterrno (ELF_E_INVALID_FILE);
290	      return NULL;
291	    }
292
293	  if (e_ident[EI_DATA] != MY_ELFDATA)
294	    {
295	      CONVERT (elf->state.elf32.ehdr_mem.e_type);
296	      CONVERT (elf->state.elf32.ehdr_mem.e_machine);
297	      CONVERT (elf->state.elf32.ehdr_mem.e_version);
298	      CONVERT (elf->state.elf32.ehdr_mem.e_entry);
299	      CONVERT (elf->state.elf32.ehdr_mem.e_phoff);
300	      CONVERT (elf->state.elf32.ehdr_mem.e_shoff);
301	      CONVERT (elf->state.elf32.ehdr_mem.e_flags);
302	      CONVERT (elf->state.elf32.ehdr_mem.e_ehsize);
303	      CONVERT (elf->state.elf32.ehdr_mem.e_phentsize);
304	      CONVERT (elf->state.elf32.ehdr_mem.e_phnum);
305	      CONVERT (elf->state.elf32.ehdr_mem.e_shentsize);
306	      CONVERT (elf->state.elf32.ehdr_mem.e_shnum);
307	      CONVERT (elf->state.elf32.ehdr_mem.e_shstrndx);
308	    }
309
310	  elf->state.elf32.ehdr = &elf->state.elf32.ehdr_mem;
311
312	  for (cnt = 0; cnt < scncnt; ++cnt)
313	    {
314	      elf->state.elf32.scns.data[cnt].index = cnt;
315	      elf->state.elf32.scns.data[cnt].elf = elf;
316	      elf->state.elf32.scns.data[cnt].list = &elf->state.elf32.scns;
317	    }
318	}
319
320      /* So far only one block with sections.  */
321      elf->state.elf32.scns_last = &elf->state.elf32.scns;
322    }
323  else
324    {
325      /* This pointer might not be directly usable if the alignment is
326	 not sufficient for the architecture.  */
327      Elf64_Ehdr *ehdr = (Elf64_Ehdr *) ((char *) map_address + offset);
328      size_t cnt;
329
330      assert ((unsigned int) scncnt == scncnt);
331      elf->state.elf64.scns.cnt = elf->state.elf64.scns.max = scncnt;
332
333      /* This is a 64-bit binary.  */
334      if (map_address != NULL && e_ident[EI_DATA] == MY_ELFDATA
335	  && (ALLOW_UNALIGNED
336	      || ((((uintptr_t) ehdr) & (__alignof__ (Elf64_Ehdr) - 1)) == 0
337		  && ((uintptr_t) ((char *) ehdr + ehdr->e_shoff)
338		      & (__alignof__ (Elf64_Shdr) - 1)) == 0
339		  && ((uintptr_t) ((char *) ehdr + ehdr->e_phoff)
340		      & (__alignof__ (Elf64_Phdr) - 1)) == 0)))
341	{
342	  /* We can use the mmapped memory.  */
343	  elf->state.elf64.ehdr =
344	    (Elf64_Ehdr *) ((char *) map_address + offset);
345	  elf->state.elf64.shdr =
346	    (Elf64_Shdr *) ((char *) map_address + offset
347			    + elf->state.elf64.ehdr->e_shoff);
348	  if (elf->state.elf64.ehdr->e_phnum)
349	    /* Assign a value only if there really is a program
350	       header.  Otherwise the value remains NULL.  */
351	    elf->state.elf64.phdr
352	      = (Elf64_Phdr *) ((char *) map_address + offset
353				+ elf->state.elf64.ehdr->e_phoff);
354
355	  for (cnt = 0; cnt < scncnt; ++cnt)
356	    {
357	      elf->state.elf64.scns.data[cnt].index = cnt;
358	      elf->state.elf64.scns.data[cnt].elf = elf;
359	      elf->state.elf64.scns.data[cnt].shdr.e64 =
360		&elf->state.elf64.shdr[cnt];
361	      elf->state.elf64.scns.data[cnt].rawdata_base =
362		elf->state.elf64.scns.data[cnt].data_base =
363		((char *) map_address + offset
364		 + elf->state.elf64.shdr[cnt].sh_offset);
365	      elf->state.elf64.scns.data[cnt].list = &elf->state.elf64.scns;
366	    }
367	}
368      else
369	{
370	  /* Read the data.  */
371	  if (pread (elf->fildes, &elf->state.elf64.ehdr_mem,
372		     sizeof (Elf64_Ehdr), offset) != sizeof (Elf64_Ehdr))
373	    {
374	      /* We must be able to read the ELF header.  */
375	      __libelf_seterrno (ELF_E_INVALID_FILE);
376	      return NULL;
377	    }
378
379	  if (e_ident[EI_DATA] != MY_ELFDATA)
380	    {
381	      CONVERT (elf->state.elf64.ehdr_mem.e_type);
382	      CONVERT (elf->state.elf64.ehdr_mem.e_machine);
383	      CONVERT (elf->state.elf64.ehdr_mem.e_version);
384	      CONVERT (elf->state.elf64.ehdr_mem.e_entry);
385	      CONVERT (elf->state.elf64.ehdr_mem.e_phoff);
386	      CONVERT (elf->state.elf64.ehdr_mem.e_shoff);
387	      CONVERT (elf->state.elf64.ehdr_mem.e_flags);
388	      CONVERT (elf->state.elf64.ehdr_mem.e_ehsize);
389	      CONVERT (elf->state.elf64.ehdr_mem.e_phentsize);
390	      CONVERT (elf->state.elf64.ehdr_mem.e_phnum);
391	      CONVERT (elf->state.elf64.ehdr_mem.e_shentsize);
392	      CONVERT (elf->state.elf64.ehdr_mem.e_shnum);
393	      CONVERT (elf->state.elf64.ehdr_mem.e_shstrndx);
394	    }
395
396	  elf->state.elf64.ehdr = &elf->state.elf64.ehdr_mem;
397
398	  for (cnt = 0; cnt < scncnt; ++cnt)
399	    {
400	      elf->state.elf64.scns.data[cnt].index = cnt;
401	      elf->state.elf64.scns.data[cnt].elf = elf;
402	      elf->state.elf64.scns.data[cnt].list = &elf->state.elf64.scns;
403	    }
404	}
405
406      /* So far only one block with sections.  */
407      elf->state.elf64.scns_last = &elf->state.elf64.scns;
408    }
409
410  /* Make the class easily available.  */
411  elf->class = e_ident[EI_CLASS];
412
413  return elf;
414}
415
416
417Elf *
418internal_function_def
419__libelf_read_mmaped_file (int fildes, void *map_address,  off_t offset,
420			   size_t maxsize, Elf_Cmd cmd, Elf *parent)
421{
422  /* We have to find out what kind of file this is.  We handle ELF
423     files and archives.  To find out what we have we must look at the
424     header.  The header for an ELF file is EI_NIDENT bytes in size,
425     the header for an archive file SARMAG bytes long.  */
426  Elf_Kind kind;
427
428  /* See what kind of object we have here.  */
429  kind = determine_kind (map_address + offset, maxsize);
430
431  switch (kind)
432    {
433    case ELF_K_ELF:
434      return file_read_elf (fildes, map_address, offset, maxsize, cmd, parent);
435
436    case ELF_K_AR:
437      return file_read_ar (fildes, map_address, offset, maxsize, cmd, parent);
438
439    default:
440      break;
441    }
442
443  /* This case is easy.  Since we cannot do anything with this file
444     create a dummy descriptor.  */
445  return allocate_elf (fildes, map_address, offset, maxsize, cmd, parent,
446		       ELF_K_NONE, 0);
447}
448
449
450static Elf *
451read_unmmaped_file (int fildes, off_t offset, size_t maxsize, Elf_Cmd cmd,
452		    Elf *parent)
453{
454  /* We have to find out what kind of file this is.  We handle ELF
455     files and archives.  To find out what we have we must read the
456     header.  The header for an ELF file is EI_NIDENT bytes in size,
457     the header for an archive file SARMAG bytes long.  Read the
458     maximum of these numbers.
459
460     XXX We have to change this for the extended `ar' format some day.  */
461  unsigned char header[MAX (EI_NIDENT, SARMAG)];
462  ssize_t nread;
463  Elf_Kind kind;
464
465  /* Read the head of the file.  */
466  nread = pread (fildes, header, MIN (MAX (EI_NIDENT, SARMAG), maxsize),
467		 offset);
468  if (nread == -1)
469    /* We cannot even read the head of the file.  Maybe FILDES is associated
470       with an unseekable device.  This is nothing we can handle.  */
471    return NULL;
472
473  /* See what kind of object we have here.  */
474  kind = determine_kind (header, nread);
475
476  switch (kind)
477    {
478    case ELF_K_AR:
479      return file_read_ar (fildes, NULL, offset, maxsize, cmd, parent);
480
481    case ELF_K_ELF:
482      /* Make sure at least the ELF header is contained in the file.  */
483      if (maxsize >= (header[EI_CLASS] == ELFCLASS32
484		      ? sizeof (Elf32_Ehdr) : sizeof (Elf64_Ehdr)))
485	return file_read_elf (fildes, NULL, offset, maxsize, cmd, parent);
486      /* FALLTHROUGH */
487
488    default:
489      break;
490    }
491
492  /* This case is easy.  Since we cannot do anything with this file
493     create a dummy descriptor.  */
494  return allocate_elf (fildes, NULL, offset, maxsize, cmd, parent,
495		       ELF_K_NONE, 0);
496}
497
498
499/* Open a file for reading.  If possible we will try to mmap() the file.  */
500static struct Elf *
501read_file (int fildes, off_t offset, size_t maxsize,
502	   Elf_Cmd cmd, Elf *parent)
503{
504  void *map_address = NULL;
505  int use_mmap = (cmd == ELF_C_READ_MMAP || cmd == ELF_C_RDWR_MMAP
506		  || cmd == ELF_C_WRITE_MMAP
507		  || cmd == ELF_C_READ_MMAP_PRIVATE);
508
509  if (use_mmap)
510    {
511      if (parent == NULL)
512	{
513	  if (maxsize == ~((size_t) 0))
514	    {
515	      /* We don't know in the moment how large the file is.
516		 Determine it now.  */
517	      struct stat st;
518
519	      if (fstat (fildes, &st) == 0
520		  && (sizeof (size_t) >= sizeof (st.st_size)
521		      || st.st_size <= ~((size_t) 0)))
522		maxsize = (size_t) st.st_size;
523	    }
524
525	  /* We try to map the file ourself.  */
526	  map_address = mmap (NULL, maxsize, (cmd == ELF_C_READ_MMAP
527					      ? PROT_READ
528					      : PROT_READ|PROT_WRITE),
529			      cmd == ELF_C_READ_MMAP_PRIVATE
530			      ? MAP_PRIVATE : MAP_SHARED,
531			      fildes, offset);
532
533	  if (map_address == MAP_FAILED)
534	    map_address = NULL;
535	}
536      else
537	{
538	  /* The parent is already loaded.  Use it.  */
539	  assert (maxsize != ~((size_t) 0));
540
541	  map_address = parent->map_address;
542	}
543    }
544
545  /* If we have the file in memory optimize the access.  */
546  if (map_address != NULL)
547    {
548      struct Elf *result;
549
550      result = __libelf_read_mmaped_file (fildes, map_address, offset, maxsize,
551					  cmd, parent);
552
553      /* If something went wrong during the initialization unmap the
554	 memory if we mmaped here.  */
555      if (result == NULL
556	  && (parent == NULL
557	      || parent->map_address != map_address))
558	munmap (map_address, maxsize);
559      else if (parent == NULL)
560	/* Remember that we mmap()ed the memory.  */
561	result->flags |= ELF_F_MMAPPED;
562
563      return result;
564    }
565
566  /* Otherwise we have to do it the hard way.  We read as much as necessary
567     from the file whenever we need information which is not available.  */
568  return read_unmmaped_file (fildes, offset, maxsize, cmd, parent);
569}
570
571
572/* Find the entry with the long names for the content of this archive.  */
573static const char *
574read_long_names (Elf *elf)
575{
576  off_t offset = SARMAG;	/* This is the first entry.  */
577  struct ar_hdr hdrm;
578  struct ar_hdr *hdr;
579  char *newp;
580  size_t len;
581
582  while (1)
583    {
584      if (elf->map_address != NULL)
585	{
586	  if (offset + sizeof (struct ar_hdr) > elf->maximum_size)
587	    return NULL;
588
589	  /* The data is mapped.  */
590	  hdr = (struct ar_hdr *) (elf->map_address + offset);
591	}
592      else
593	{
594	  /* Read the header from the file.  */
595	  if (pread (elf->fildes, &hdrm, sizeof (hdrm),
596		     elf->start_offset + offset) != sizeof (hdrm))
597	    return NULL;
598
599	  hdr = &hdrm;
600	}
601
602      len = atol (hdr->ar_size);
603
604      if (memcmp (hdr->ar_name, "//              ", 16) == 0)
605	break;
606
607      offset += sizeof (struct ar_hdr) + ((len + 1) & ~1l);
608    }
609
610  /* Due to the stupid format of the long name table entry (which are not
611     NUL terminted) we have to provide an appropriate representation anyhow.
612     Therefore we always make a copy which has the appropriate form.  */
613  newp = (char *) malloc (len);
614  if (newp != NULL)
615    {
616      char *runp;
617
618      if (elf->map_address != NULL)
619	/* Simply copy it over.  */
620	elf->state.ar.long_names = (char *) memcpy (newp,
621						    elf->map_address + offset
622						    + sizeof (struct ar_hdr),
623						    len);
624      else
625	{
626	  if ((size_t) pread (elf->fildes, newp, len,
627			      elf->start_offset + offset
628			      + sizeof (struct ar_hdr))
629	      != len)
630	    {
631	      /* We were not able to read all data.  */
632	      free (newp);
633	      elf->state.ar.long_names = NULL;
634	      return NULL;
635	    }
636	  elf->state.ar.long_names = newp;
637	}
638
639      elf->state.ar.long_names_len = len;
640
641      /* Now NUL-terminate the strings.  */
642      runp = newp;
643      while (1)
644        {
645	  runp = (char *) memchr (runp, '/', newp + len - runp);
646	  if (runp == NULL)
647	    /* This was the last entry.  */
648	    break;
649
650	  /* NUL-terminate the string.  */
651	  *runp = '\0';
652
653	  /* Skip the NUL bzte and the \012.  */
654	  runp += 2;
655
656	  /* A sanity check.  Somebody might have generated invalid
657	     archive.  */
658	  if (runp >= newp + len)
659	    break;
660	}
661    }
662
663  return newp;
664}
665
666
667/* Read the next archive header.  */
668int
669internal_function_def
670__libelf_next_arhdr (elf)
671     Elf *elf;
672{
673  struct ar_hdr *ar_hdr;
674  Elf_Arhdr *elf_ar_hdr;
675
676  if (elf->map_address != NULL)
677    {
678      /* See whether this entry is in the file.  */
679      if (elf->state.ar.offset + sizeof (struct ar_hdr)
680	  > elf->start_offset + elf->maximum_size)
681	{
682	  /* This record is not anymore in the file.  */
683	  __libelf_seterrno (ELF_E_RANGE);
684	  return -1;
685	}
686      ar_hdr = (struct ar_hdr *) (elf->map_address + elf->state.ar.offset);
687    }
688  else
689    {
690      ar_hdr = &elf->state.ar.ar_hdr;
691
692      if (pread (elf->fildes, ar_hdr, sizeof (struct ar_hdr),
693		 elf->state.ar.offset)
694	  != sizeof (struct ar_hdr))
695	{
696	  /* Something went wrong while reading the file.  */
697	  __libelf_seterrno (ELF_E_RANGE);
698	  return -1;
699	}
700    }
701
702  /* One little consistency check.  */
703  if (memcmp (ar_hdr->ar_fmag, ARFMAG, 2) != 0)
704    {
705      /* This is no valid archive.  */
706      __libelf_seterrno (ELF_E_ARCHIVE_FMAG);
707      return -1;
708    }
709
710  /* Copy the raw name over to a NUL terminated buffer.  */
711  *((char *) __mempcpy (elf->state.ar.raw_name, ar_hdr->ar_name, 16)) = '\0';
712
713  elf_ar_hdr = &elf->state.ar.elf_ar_hdr;
714
715  /* Now convert the `struct ar_hdr' into `Elf_Arhdr'.
716     Determine whether this is a special entry.  */
717  if (ar_hdr->ar_name[0] == '/')
718    {
719      if (ar_hdr->ar_name[1] == ' '
720	  && memcmp (ar_hdr->ar_name, "/               ", 16) == 0)
721	/* This is the index.  */
722	elf_ar_hdr->ar_name = memcpy (elf->state.ar.ar_name, "/", 2);
723      else if (ar_hdr->ar_name[1] == '/'
724	       && memcmp (ar_hdr->ar_name, "//              ", 16) == 0)
725	/* This is the array with the long names.  */
726	elf_ar_hdr->ar_name = memcpy (elf->state.ar.ar_name, "//", 3);
727      else if (isdigit (ar_hdr->ar_name[1]))
728	{
729	  size_t offset;
730
731	  /* This is a long name.  First we have to read the long name
732	     table, if this hasn't happened already.  */
733	  if (elf->state.ar.long_names == NULL
734	      && read_long_names (elf) == NULL)
735	    {
736	      /* No long name table although it is reference.  The archive is
737		 broken.  */
738	      __libelf_seterrno (ELF_E_INVALID_ARCHIVE);
739	      return -1;
740	    }
741
742	  offset = atol (ar_hdr->ar_name + 1);
743	  if (offset >= elf->state.ar.long_names_len)
744	    {
745	      /* The index in the long name table is larger than the table.  */
746	      __libelf_seterrno (ELF_E_INVALID_ARCHIVE);
747	      return -1;
748	    }
749	  elf_ar_hdr->ar_name = elf->state.ar.long_names + offset;
750	}
751      else
752	{
753	  /* This is none of the known special entries.  */
754	  __libelf_seterrno (ELF_E_INVALID_ARCHIVE);
755	  return -1;
756	}
757    }
758  else
759    {
760      char *endp;
761
762      /* It is a normal entry.  Copy over the name.  */
763      endp = (char *) memccpy (elf->state.ar.ar_name, ar_hdr->ar_name,
764			       '/', 16);
765      if (endp != NULL)
766	endp[-1] = '\0';
767      else
768	elf->state.ar.raw_name[16] = '\0';
769
770      elf_ar_hdr->ar_name = elf->state.ar.ar_name;
771    }
772
773  /* Since there are no specialized functions to convert ASCII to
774     time_t, uid_t, gid_t, mode_t, and off_t we use either atol or
775     atoll depending on the size of the types.  We are also prepared
776     for the case where the whole field in the `struct ar_hdr' is
777     filled in which case we cannot simply use atol/l but instead have
778     to create a temporary copy.  */
779  if (ar_hdr->ar_date[sizeof (ar_hdr->ar_date) - 1] == ' ')
780    {
781      if (ar_hdr->ar_date[0] == ' ')
782	elf_ar_hdr->ar_date = 0;
783      else
784	elf_ar_hdr->ar_date = (sizeof (time_t) <= sizeof (long int)
785			       ? (time_t) atol (ar_hdr->ar_date)
786			       : (time_t) atoll (ar_hdr->ar_date));
787    }
788  else
789    {
790      char buf[sizeof (ar_hdr->ar_date) + 1];
791      *((char *) __mempcpy (buf, ar_hdr->ar_date, sizeof (ar_hdr->ar_date)))
792	= '\0';
793      elf_ar_hdr->ar_date = (sizeof (time_t) <= sizeof (long int)
794			     ? (time_t) atol (ar_hdr->ar_date)
795			     : (time_t) atoll (ar_hdr->ar_date));
796    }
797
798  if (ar_hdr->ar_uid[sizeof (ar_hdr->ar_uid) - 1] == ' ')
799    {
800      if (ar_hdr->ar_uid[0] == ' ')
801	elf_ar_hdr->ar_uid = 0;
802      else
803	elf_ar_hdr->ar_uid = (sizeof (uid_t) <= sizeof (long int)
804			      ? (uid_t) atol (ar_hdr->ar_uid)
805			      : (uid_t) atoll (ar_hdr->ar_uid));
806    }
807  else
808    {
809      char buf[sizeof (ar_hdr->ar_uid) + 1];
810      *((char *) __mempcpy (buf, ar_hdr->ar_uid, sizeof (ar_hdr->ar_uid)))
811	= '\0';
812      elf_ar_hdr->ar_uid = (sizeof (uid_t) <= sizeof (long int)
813			     ? (uid_t) atol (ar_hdr->ar_uid)
814			     : (uid_t) atoll (ar_hdr->ar_uid));
815    }
816
817  if (ar_hdr->ar_gid[sizeof (ar_hdr->ar_gid) - 1] == ' ')
818    {
819      if (ar_hdr->ar_gid[0] == ' ')
820	elf_ar_hdr->ar_gid = 0;
821      else
822	elf_ar_hdr->ar_gid = (sizeof (gid_t) <= sizeof (long int)
823			      ? (gid_t) atol (ar_hdr->ar_gid)
824			      : (gid_t) atoll (ar_hdr->ar_gid));
825    }
826  else
827    {
828      char buf[sizeof (ar_hdr->ar_gid) + 1];
829      *((char *) __mempcpy (buf, ar_hdr->ar_gid, sizeof (ar_hdr->ar_gid)))
830	= '\0';
831      elf_ar_hdr->ar_gid = (sizeof (gid_t) <= sizeof (long int)
832			     ? (gid_t) atol (ar_hdr->ar_gid)
833			     : (gid_t) atoll (ar_hdr->ar_gid));
834    }
835
836  if (ar_hdr->ar_mode[sizeof (ar_hdr->ar_mode) - 1] == ' ')
837    {
838      if (ar_hdr->ar_mode[0] == ' ')
839	elf_ar_hdr->ar_mode = 0;
840      else
841	elf_ar_hdr->ar_mode = (sizeof (mode_t) <= sizeof (long int)
842			       ? (mode_t) strtol (ar_hdr->ar_mode, NULL, 8)
843			       : (mode_t) strtoll (ar_hdr->ar_mode, NULL, 8));
844    }
845  else
846    {
847      char buf[sizeof (ar_hdr->ar_mode) + 1];
848      *((char *) __mempcpy (buf, ar_hdr->ar_mode, sizeof (ar_hdr->ar_mode)))
849	= '\0';
850      elf_ar_hdr->ar_mode = (sizeof (mode_t) <= sizeof (long int)
851			     ? (mode_t) strtol (ar_hdr->ar_mode, NULL, 8)
852			     : (mode_t) strtoll (ar_hdr->ar_mode, NULL, 8));
853    }
854
855  if (ar_hdr->ar_size[sizeof (ar_hdr->ar_size) - 1] == ' ')
856    {
857      if (ar_hdr->ar_size[0] == ' ')
858	/* Something is really wrong.  We cannot live without a size for
859	   the member since it will not be possible to find the next
860	   archive member.  */
861	{
862	  __libelf_seterrno (ELF_E_INVALID_ARCHIVE);
863	  return -1;
864	}
865      else
866	elf_ar_hdr->ar_size = (sizeof (time_t) == sizeof (long int)
867			       ? (off_t) atol (ar_hdr->ar_size)
868			       : (off_t) atoll (ar_hdr->ar_size));
869    }
870  else
871    {
872      char buf[sizeof (ar_hdr->ar_size) + 1];
873      *((char *) __mempcpy (buf, ar_hdr->ar_size, sizeof (ar_hdr->ar_size)))
874	= '\0';
875      elf_ar_hdr->ar_size = (sizeof (time_t) == sizeof (long int)
876			     ? (off_t) atol (ar_hdr->ar_size)
877			     : (off_t) atoll (ar_hdr->ar_size));
878    }
879
880  return 0;
881}
882
883
884/* We were asked to return a clone of an existing descriptor.  This
885   function must be called with the lock on the parent descriptor
886   being held. */
887static Elf *
888dup_elf (int fildes, Elf_Cmd cmd, Elf *ref)
889{
890  struct Elf *result;
891
892  if (fildes == -1)
893    /* Allow the user to pass -1 as the file descriptor for the new file.  */
894    fildes = ref->fildes;
895  /* The file descriptor better should be the same.  If it was disconnected
896     already (using `elf_cntl') we do not test it.  */
897  else if (ref->fildes != -1 && fildes != ref->fildes)
898    {
899      __libelf_seterrno (ELF_E_FD_MISMATCH);
900      return NULL;
901    }
902
903  /* The mode must allow reading.  I.e., a descriptor creating with a
904     command different then ELF_C_READ, ELF_C_WRITE and ELF_C_RDWR is
905     not allowed.  */
906  if (ref->cmd != ELF_C_READ && ref->cmd != ELF_C_READ_MMAP
907      && ref->cmd != ELF_C_WRITE && ref->cmd != ELF_C_WRITE_MMAP
908      && ref->cmd != ELF_C_RDWR && ref->cmd != ELF_C_RDWR_MMAP
909      && ref->cmd != ELF_C_READ_MMAP_PRIVATE)
910    {
911      __libelf_seterrno (ELF_E_INVALID_OP);
912      return NULL;
913    }
914
915  /* Now it is time to distinguish between reading normal files and
916     archives.  Normal files can easily be handled be incrementing the
917     reference counter and return the same descriptor.  */
918  if (ref->kind != ELF_K_AR)
919    {
920      ++ref->ref_count;
921      return ref;
922    }
923
924  /* This is an archive.  We must create a descriptor for the archive
925     member the internal pointer of the archive file desriptor is
926     pointing to.  First read the header of the next member if this
927     has not happened already.  */
928  if (ref->state.ar.elf_ar_hdr.ar_name == NULL
929      && __libelf_next_arhdr (ref) != 0)
930    /* Something went wrong.  Maybe there is no member left.  */
931    return NULL;
932
933  /* We have all the information we need about the next archive member.
934     Now create a descriptor for it.  */
935  result = read_file (fildes, ref->state.ar.offset + sizeof (struct ar_hdr),
936		      ref->state.ar.elf_ar_hdr.ar_size, cmd, ref);
937
938  /* Enlist this new descriptor in the list of children.  */
939  if (result != NULL)
940    {
941      result->next = ref->state.ar.children;
942      ref->state.ar.children = result;
943    }
944
945  return result;
946}
947
948
949/* Return desriptor for empty file ready for writing.  */
950static struct Elf *
951write_file (int fd, Elf_Cmd cmd)
952{
953  /* We simply create an empty `Elf' structure.  */
954#define NSCNSALLOC	10
955  Elf *result = allocate_elf (fd, NULL, 0, 0, cmd, NULL, ELF_K_ELF,
956			      NSCNSALLOC * sizeof (Elf_Scn));
957
958  if (result != NULL)
959    {
960      /* We have to write to the file in any case.  */
961      result->flags = ELF_F_DIRTY;
962
963      /* Some more or less arbitrary value.  */
964      result->state.elf.scnincr = NSCNSALLOC;
965
966      /* We have allocated room for some sections.  */
967      assert (offsetof (struct Elf, state.elf32.scns)
968	      == offsetof (struct Elf, state.elf64.scns));
969      result->state.elf.scns_last = &result->state.elf32.scns;
970      result->state.elf32.scns.max = NSCNSALLOC;
971    }
972
973  return result;
974}
975
976
977/* Return a descriptor for the file belonging to FILDES.  */
978Elf *
979elf_begin (fildes, cmd, ref)
980     int fildes;
981     Elf_Cmd cmd;
982     Elf *ref;
983{
984  Elf *retval;
985
986  if (! __libelf_version_initialized)
987    {
988      /* Version wasn't set so far.  */
989      __libelf_seterrno (ELF_E_NO_VERSION);
990      return NULL;
991    }
992
993  if (ref != NULL)
994    /* Make sure the descriptor is not suddenly going away.  */
995    rwlock_rdlock (ref->lock);
996  else if (fcntl (fildes, F_GETFL) == -1 && errno == EBADF)
997    {
998      /* We cannot do anything productive without a file descriptor.  */
999      __libelf_seterrno (ELF_E_INVALID_FILE);
1000      return NULL;
1001    }
1002
1003  switch (cmd)
1004    {
1005    case ELF_C_NULL:
1006      /* We simply return a NULL pointer.  */
1007      retval = NULL;
1008      break;
1009
1010    case ELF_C_READ_MMAP_PRIVATE:
1011      /* If we have a reference it must also be opened this way.  */
1012      if (ref != NULL && ref->cmd != ELF_C_READ_MMAP_PRIVATE)
1013	{
1014	  __libelf_seterrno (ELF_E_INVALID_CMD);
1015	  retval = NULL;
1016	  break;
1017	}
1018      /* FALLTHROUGH */
1019
1020    case ELF_C_READ:
1021    case ELF_C_READ_MMAP:
1022      if (ref != NULL)
1023	/* Duplicate the descriptor.  */
1024	retval = dup_elf (fildes, cmd, ref);
1025      else
1026	/* Create descriptor for existing file.  */
1027	retval = read_file (fildes, 0, ~((size_t) 0), cmd, NULL);
1028      break;
1029
1030    case ELF_C_RDWR:
1031    case ELF_C_RDWR_MMAP:
1032      /* If we have a REF object it must also be opened using this
1033	 command.  */
1034      if (ref != NULL)
1035	{
1036	  if (ref->cmd != ELF_C_RDWR && ref->cmd != ELF_C_RDWR_MMAP
1037	      && ref->cmd != ELF_C_WRITE && ref->cmd != ELF_C_WRITE_MMAP)
1038	    {
1039	      /* This is not ok.  REF must also be opened for writing.  */
1040	      __libelf_seterrno (ELF_E_INVALID_CMD);
1041	      retval = NULL;
1042	    }
1043	  else
1044	    /* Duplicate this descriptor.  */
1045	    retval = dup_elf (fildes, cmd, ref);
1046	}
1047      else
1048	/* Create descriptor for existing file.  */
1049	retval = read_file (fildes, 0, ~((size_t) 0), cmd, NULL);
1050      break;
1051
1052    case ELF_C_WRITE:
1053    case ELF_C_WRITE_MMAP:
1054      /* We ignore REF and prepare a descriptor to write a new file.  */
1055      retval = write_file (fildes, cmd);
1056      break;
1057
1058    default:
1059      __libelf_seterrno (ELF_E_INVALID_CMD);
1060      retval = NULL;
1061      break;
1062    }
1063
1064  /* Release the lock.  */
1065  if (ref != NULL)
1066    rwlock_unlock (ref->lock);
1067
1068  return retval;
1069}
1070INTDEF(elf_begin)
1071