1/*
2 * Copyright (c) 1989, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if defined(LIBC_SCCS) && !defined(lint)
31static char sccsid[] = "@(#)nlist.c	8.1 (Berkeley) 6/4/93";
32#endif /* LIBC_SCCS and not lint */
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD$");
35
36#include "namespace.h"
37#include <sys/param.h>
38#include <sys/mman.h>
39#include <sys/stat.h>
40#include <sys/file.h>
41#include <arpa/inet.h>
42
43#include <errno.h>
44#include <a.out.h>
45#include <stdio.h>
46#include <string.h>
47#include <unistd.h>
48#include "un-namespace.h"
49
50/* i386 is the only current FreeBSD architecture that used a.out format. */
51#ifdef __i386__
52#define _NLIST_DO_AOUT
53#endif
54#define _NLIST_DO_ELF
55
56#ifdef _NLIST_DO_ELF
57#include <machine/elf.h>
58#include <elf-hints.h>
59#endif
60
61int __fdnlist(int, struct nlist *);
62int __aout_fdnlist(int, struct nlist *);
63int __elf_fdnlist(int, struct nlist *);
64int __elf_is_okay__(Elf_Ehdr *);
65
66int
67nlist(const char *name, struct nlist *list)
68{
69	int fd, n;
70
71	fd = _open(name, O_RDONLY | O_CLOEXEC, 0);
72	if (fd < 0)
73		return (-1);
74	n = __fdnlist(fd, list);
75	(void)_close(fd);
76	return (n);
77}
78
79static struct nlist_handlers {
80	int	(*fn)(int fd, struct nlist *list);
81} nlist_fn[] = {
82#ifdef _NLIST_DO_AOUT
83	{ __aout_fdnlist },
84#endif
85#ifdef _NLIST_DO_ELF
86	{ __elf_fdnlist },
87#endif
88};
89
90int
91__fdnlist(int fd, struct nlist *list)
92{
93	int n = -1;
94	unsigned int i;
95
96	for (i = 0; i < nitems(nlist_fn); i++) {
97		n = (nlist_fn[i].fn)(fd, list);
98		if (n != -1)
99			break;
100	}
101	return (n);
102}
103
104#define	ISLAST(p)	(p->n_un.n_name == 0 || p->n_un.n_name[0] == 0)
105
106#ifdef _NLIST_DO_AOUT
107int
108__aout_fdnlist(int fd, struct nlist *list)
109{
110	struct nlist *p, *symtab;
111	caddr_t strtab, a_out_mmap;
112	off_t stroff, symoff;
113	u_long symsize;
114	int nent;
115	struct exec * exec;
116	struct stat st;
117
118	/* check that file is at least as large as struct exec! */
119	if ((_fstat(fd, &st) < 0) || (st.st_size < sizeof(struct exec)))
120		return (-1);
121
122	/* Check for files too large to mmap. */
123	if (st.st_size > SIZE_T_MAX) {
124		errno = EFBIG;
125		return (-1);
126	}
127
128	/*
129	 * Map the whole a.out file into our address space.
130	 * We then find the string table withing this area.
131	 * We do not just mmap the string table, as it probably
132	 * does not start at a page boundary - we save ourselves a
133	 * lot of nastiness by mmapping the whole file.
134	 *
135	 * This gives us an easy way to randomly access all the strings,
136	 * without making the memory allocation permanent as with
137	 * malloc/free (i.e., munmap will return it to the system).
138	 */
139	a_out_mmap = mmap(NULL, (size_t)st.st_size, PROT_READ, MAP_PRIVATE, fd, (off_t)0);
140	if (a_out_mmap == MAP_FAILED)
141		return (-1);
142
143	exec = (struct exec *)a_out_mmap;
144	if (N_BADMAG(*exec)) {
145		munmap(a_out_mmap, (size_t)st.st_size);
146		return (-1);
147	}
148
149	symoff = N_SYMOFF(*exec);
150	symsize = exec->a_syms;
151	stroff = symoff + symsize;
152
153	/* find the string table in our mmapped area */
154	strtab = a_out_mmap + stroff;
155	symtab = (struct nlist *)(a_out_mmap + symoff);
156
157	/*
158	 * clean out any left-over information for all valid entries.
159	 * Type and value defined to be 0 if not found; historical
160	 * versions cleared other and desc as well.  Also figure out
161	 * the largest string length so don't read any more of the
162	 * string table than we have to.
163	 *
164	 * XXX clearing anything other than n_type and n_value violates
165	 * the semantics given in the man page.
166	 */
167	nent = 0;
168	for (p = list; !ISLAST(p); ++p) {
169		p->n_type = 0;
170		p->n_other = 0;
171		p->n_desc = 0;
172		p->n_value = 0;
173		++nent;
174	}
175
176	while (symsize > 0) {
177		int soff;
178
179		symsize-= sizeof(struct nlist);
180		soff = symtab->n_un.n_strx;
181
182
183		if (soff != 0 && (symtab->n_type & N_STAB) == 0)
184			for (p = list; !ISLAST(p); p++)
185				if (!strcmp(&strtab[soff], p->n_un.n_name)) {
186					p->n_value = symtab->n_value;
187					p->n_type = symtab->n_type;
188					p->n_desc = symtab->n_desc;
189					p->n_other = symtab->n_other;
190					if (--nent <= 0)
191						break;
192				}
193		symtab++;
194	}
195	munmap(a_out_mmap, (size_t)st.st_size);
196	return (nent);
197}
198#endif
199
200#ifdef _NLIST_DO_ELF
201static void elf_sym_to_nlist(struct nlist *, Elf_Sym *, Elf_Shdr *, int);
202
203/*
204 * __elf_is_okay__ - Determine if ehdr really
205 * is ELF and valid for the target platform.
206 *
207 * WARNING:  This is NOT an ELF ABI function and
208 * as such its use should be restricted.
209 */
210int
211__elf_is_okay__(Elf_Ehdr *ehdr)
212{
213	int retval = 0;
214	/*
215	 * We need to check magic, class size, endianess,
216	 * and version before we look at the rest of the
217	 * Elf_Ehdr structure.  These few elements are
218	 * represented in a machine independant fashion.
219	 */
220	if (IS_ELF(*ehdr) &&
221	    ehdr->e_ident[EI_CLASS] == ELF_TARG_CLASS &&
222	    ehdr->e_ident[EI_DATA] == ELF_TARG_DATA &&
223	    ehdr->e_ident[EI_VERSION] == ELF_TARG_VER) {
224
225		/* Now check the machine dependant header */
226		if (ehdr->e_machine == ELF_TARG_MACH &&
227		    ehdr->e_version == ELF_TARG_VER)
228			retval = 1;
229	}
230	return retval;
231}
232
233int
234__elf_fdnlist(int fd, struct nlist *list)
235{
236	struct nlist *p;
237	Elf_Off symoff = 0, symstroff = 0;
238	Elf_Size symsize = 0, symstrsize = 0;
239	Elf_Ssize cc, i;
240	int nent = -1;
241	int errsave;
242	Elf_Sym sbuf[1024];
243	Elf_Sym *s;
244	Elf_Ehdr ehdr;
245	char *strtab = NULL;
246	Elf_Shdr *shdr = NULL;
247	Elf_Size shdr_size;
248	void *base;
249	struct stat st;
250
251	/* Make sure obj is OK */
252	if (lseek(fd, (off_t)0, SEEK_SET) == -1 ||
253	    _read(fd, &ehdr, sizeof(Elf_Ehdr)) != sizeof(Elf_Ehdr) ||
254	    !__elf_is_okay__(&ehdr) ||
255	    _fstat(fd, &st) < 0)
256		return (-1);
257
258	/* calculate section header table size */
259	shdr_size = ehdr.e_shentsize * ehdr.e_shnum;
260
261	/* Make sure it's not too big to mmap */
262	if (shdr_size > SIZE_T_MAX) {
263		errno = EFBIG;
264		return (-1);
265	}
266
267	/* mmap section header table */
268	base = mmap(NULL, (size_t)shdr_size, PROT_READ, MAP_PRIVATE, fd,
269	    (off_t)ehdr.e_shoff);
270	if (base == MAP_FAILED)
271		return (-1);
272	shdr = (Elf_Shdr *)base;
273
274	/*
275	 * Find the symbol table entry and it's corresponding
276	 * string table entry.	Version 1.1 of the ABI states
277	 * that there is only one symbol table but that this
278	 * could change in the future.
279	 */
280	for (i = 0; i < ehdr.e_shnum; i++) {
281		if (shdr[i].sh_type == SHT_SYMTAB) {
282			symoff = shdr[i].sh_offset;
283			symsize = shdr[i].sh_size;
284			symstroff = shdr[shdr[i].sh_link].sh_offset;
285			symstrsize = shdr[shdr[i].sh_link].sh_size;
286			break;
287		}
288	}
289
290	/* Check for files too large to mmap. */
291	if (symstrsize > SIZE_T_MAX) {
292		errno = EFBIG;
293		goto done;
294	}
295	/*
296	 * Map string table into our address space.  This gives us
297	 * an easy way to randomly access all the strings, without
298	 * making the memory allocation permanent as with malloc/free
299	 * (i.e., munmap will return it to the system).
300	 */
301	base = mmap(NULL, (size_t)symstrsize, PROT_READ, MAP_PRIVATE, fd,
302	    (off_t)symstroff);
303	if (base == MAP_FAILED)
304		goto done;
305	strtab = (char *)base;
306
307	/*
308	 * clean out any left-over information for all valid entries.
309	 * Type and value defined to be 0 if not found; historical
310	 * versions cleared other and desc as well.  Also figure out
311	 * the largest string length so don't read any more of the
312	 * string table than we have to.
313	 *
314	 * XXX clearing anything other than n_type and n_value violates
315	 * the semantics given in the man page.
316	 */
317	nent = 0;
318	for (p = list; !ISLAST(p); ++p) {
319		p->n_type = 0;
320		p->n_other = 0;
321		p->n_desc = 0;
322		p->n_value = 0;
323		++nent;
324	}
325
326	/* Don't process any further if object is stripped. */
327	if (symoff == 0)
328		goto done;
329
330	if (lseek(fd, (off_t) symoff, SEEK_SET) == -1) {
331		nent = -1;
332		goto done;
333	}
334
335	while (symsize > 0 && nent > 0) {
336		cc = MIN(symsize, sizeof(sbuf));
337		if (_read(fd, sbuf, cc) != cc)
338			break;
339		symsize -= cc;
340		for (s = sbuf; cc > 0 && nent > 0; ++s, cc -= sizeof(*s)) {
341			char *name;
342			struct nlist *p;
343
344			name = strtab + s->st_name;
345			if (name[0] == '\0')
346				continue;
347			for (p = list; !ISLAST(p); p++) {
348				if ((p->n_un.n_name[0] == '_' &&
349				    strcmp(name, p->n_un.n_name+1) == 0)
350				    || strcmp(name, p->n_un.n_name) == 0) {
351					elf_sym_to_nlist(p, s, shdr,
352					    ehdr.e_shnum);
353					if (--nent <= 0)
354						break;
355				}
356			}
357		}
358	}
359  done:
360	errsave = errno;
361	if (strtab != NULL)
362		munmap(strtab, symstrsize);
363	if (shdr != NULL)
364		munmap(shdr, shdr_size);
365	errno = errsave;
366	return (nent);
367}
368
369/*
370 * Convert an Elf_Sym into an nlist structure.  This fills in only the
371 * n_value and n_type members.
372 */
373static void
374elf_sym_to_nlist(struct nlist *nl, Elf_Sym *s, Elf_Shdr *shdr, int shnum)
375{
376	nl->n_value = s->st_value;
377
378	switch (s->st_shndx) {
379	case SHN_UNDEF:
380	case SHN_COMMON:
381		nl->n_type = N_UNDF;
382		break;
383	case SHN_ABS:
384		nl->n_type = ELF_ST_TYPE(s->st_info) == STT_FILE ?
385		    N_FN : N_ABS;
386		break;
387	default:
388		if (s->st_shndx >= shnum)
389			nl->n_type = N_UNDF;
390		else {
391			Elf_Shdr *sh = shdr + s->st_shndx;
392
393			nl->n_type = sh->sh_type == SHT_PROGBITS ?
394			    (sh->sh_flags & SHF_WRITE ? N_DATA : N_TEXT) :
395			    (sh->sh_type == SHT_NOBITS ? N_BSS : N_UNDF);
396		}
397		break;
398	}
399
400	if (ELF_ST_BIND(s->st_info) == STB_GLOBAL ||
401	    ELF_ST_BIND(s->st_info) == STB_WEAK)
402		nl->n_type |= N_EXT;
403}
404#endif /* _NLIST_DO_ELF */
405