1/*-
2 * SPDX-License-Identifier: BSD-4-Clause
3 *
4 * Copyright (c) 1993 Paul Kranenburg
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *      This product includes software developed by Paul Kranenburg.
18 * 4. The name of the author may not be used to endorse or promote products
19 *    derived from this software without specific prior written permission
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD$");
35
36#include <sys/param.h>
37#include <sys/wait.h>
38
39#include <machine/elf.h>
40
41#include <arpa/inet.h>
42
43#include <dlfcn.h>
44#include <err.h>
45#include <errno.h>
46#include <fcntl.h>
47#include <gelf.h>
48#include <libelf.h>
49#include <stdbool.h>
50#include <stdio.h>
51#include <stdlib.h>
52#include <string.h>
53#include <unistd.h>
54
55/*
56 * 32-bit ELF data structures can only be used if the system header[s] declare
57 * them.  There is no official macro for determining whether they are declared,
58 * so check for the existence of one of the 32-macros defined in elf(5).
59 */
60#ifdef ELF32_R_TYPE
61#define	ELF32_SUPPORTED
62#endif
63
64#define	LDD_SETENV(name, value, overwrite) do {		\
65	setenv("LD_" name, value, overwrite);		\
66	setenv("LD_32_" name, value, overwrite);	\
67} while (0)
68
69#define	LDD_UNSETENV(name) do {		\
70	unsetenv("LD_" name);		\
71	unsetenv("LD_32_" name);	\
72} while (0)
73
74static int	is_executable(const char *fname, int fd, int *is_shlib,
75		    int *type);
76static void	usage(void);
77
78#define	TYPE_UNKNOWN	0
79#define	TYPE_ELF	1	/* Architecture default */
80#if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
81#define	TYPE_ELF32	2	/* Explicit 32 bits on architectures >32 bits */
82
83#define	_PATH_LDD32	"/usr/bin/ldd32"
84
85static int
86execldd32(char *file, char *fmt1, char *fmt2, int aflag, int vflag)
87{
88	char *argv[9];
89	int i, rval, status;
90
91	LDD_UNSETENV("TRACE_LOADED_OBJECTS");
92	rval = 0;
93	i = 0;
94	argv[i++] = strdup(_PATH_LDD32);
95	if (aflag)
96		argv[i++] = strdup("-a");
97	if (vflag)
98		argv[i++] = strdup("-v");
99	if (fmt1 != NULL) {
100		argv[i++] = strdup("-f");
101		argv[i++] = strdup(fmt1);
102	}
103	if (fmt2 != NULL) {
104		argv[i++] = strdup("-f");
105		argv[i++] = strdup(fmt2);
106	}
107	argv[i++] = strdup(file);
108	argv[i++] = NULL;
109
110	switch (fork()) {
111	case -1:
112		err(1, "fork");
113		break;
114	case 0:
115		execv(_PATH_LDD32, argv);
116		warn("%s", _PATH_LDD32);
117		_exit(127);
118		break;
119	default:
120		if (wait(&status) < 0)
121			rval = 1;
122		else if (WIFSIGNALED(status))
123			rval = 1;
124		else if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
125			rval = 1;
126		break;
127	}
128	while (i--)
129		free(argv[i]);
130	LDD_SETENV("TRACE_LOADED_OBJECTS", "yes", 1);
131	return (rval);
132}
133#endif
134
135int
136main(int argc, char *argv[])
137{
138	char *fmt1, *fmt2;
139	int rval, c, aflag, vflag;
140
141	aflag = vflag = 0;
142	fmt1 = fmt2 = NULL;
143
144	while ((c = getopt(argc, argv, "af:v")) != -1) {
145		switch (c) {
146		case 'a':
147			aflag++;
148			break;
149		case 'f':
150			if (fmt1 != NULL) {
151				if (fmt2 != NULL)
152					errx(1, "too many formats");
153				fmt2 = optarg;
154			} else
155				fmt1 = optarg;
156			break;
157		case 'v':
158			vflag++;
159			break;
160		default:
161			usage();
162			/* NOTREACHED */
163		}
164	}
165	argc -= optind;
166	argv += optind;
167
168	if (vflag && fmt1 != NULL)
169		errx(1, "-v may not be used with -f");
170
171	if (argc <= 0) {
172		usage();
173		/* NOTREACHED */
174	}
175
176	rval = 0;
177	for (; argc > 0; argc--, argv++) {
178		int fd, status, is_shlib, rv, type;
179
180		if ((fd = open(*argv, O_RDONLY, 0)) < 0) {
181			warn("%s", *argv);
182			rval |= 1;
183			continue;
184		}
185		rv = is_executable(*argv, fd, &is_shlib, &type);
186		close(fd);
187		if (rv == 0) {
188			rval |= 1;
189			continue;
190		}
191
192		switch (type) {
193		case TYPE_ELF:
194			break;
195#if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
196		case TYPE_ELF32:
197			rval |= execldd32(*argv, fmt1, fmt2, aflag, vflag);
198			continue;
199#endif
200		case TYPE_UNKNOWN:
201		default:
202			/*
203			 * This shouldn't happen unless is_executable()
204			 * is broken.
205			 */
206			errx(EDOOFUS, "unknown executable type");
207		}
208
209		/* ld.so magic */
210		LDD_SETENV("TRACE_LOADED_OBJECTS", "yes", 1);
211		if (fmt1 != NULL)
212			LDD_SETENV("TRACE_LOADED_OBJECTS_FMT1", fmt1, 1);
213		if (fmt2 != NULL)
214			LDD_SETENV("TRACE_LOADED_OBJECTS_FMT2", fmt2, 1);
215
216		LDD_SETENV("TRACE_LOADED_OBJECTS_PROGNAME", *argv, 1);
217		if (aflag)
218			LDD_SETENV("TRACE_LOADED_OBJECTS_ALL", "1", 1);
219		else if (fmt1 == NULL && fmt2 == NULL)
220			/* Default formats */
221			printf("%s:\n", *argv);
222		fflush(stdout);
223
224		switch (fork()) {
225		case -1:
226			err(1, "fork");
227			break;
228		default:
229			if (wait(&status) < 0) {
230				warn("wait");
231				rval |= 1;
232			} else if (WIFSIGNALED(status)) {
233				fprintf(stderr, "%s: signal %d\n", *argv,
234				    WTERMSIG(status));
235				rval |= 1;
236			} else if (WIFEXITED(status) &&
237			    WEXITSTATUS(status) != 0) {
238				fprintf(stderr, "%s: exit status %d\n", *argv,
239				    WEXITSTATUS(status));
240				rval |= 1;
241			}
242			break;
243		case 0:
244			if (is_shlib == 0) {
245				execl(*argv, *argv, (char *)NULL);
246				warn("%s", *argv);
247			} else {
248				dlopen(*argv, RTLD_TRACE);
249				warnx("%s: %s", *argv, dlerror());
250			}
251			_exit(1);
252		}
253	}
254
255	return rval;
256}
257
258static void
259usage(void)
260{
261
262	fprintf(stderr, "usage: ldd [-a] [-v] [-f format] program ...\n");
263	exit(1);
264}
265
266static bool
267has_freebsd_abi_tag(const char *fname, Elf *elf, GElf_Ehdr *ehdr, off_t offset,
268    size_t len)
269{
270	Elf_Data dst, src;
271	const Elf_Note *note;
272	char *buf;
273	const char *name;
274	void *copy;
275	size_t namesz, descsz;
276	bool has_abi_tag;
277
278	buf = elf_rawfile(elf, NULL);
279	if (buf == NULL) {
280		warnx("%s: %s", fname, elf_errmsg(0));
281		return (false);
282	}
283
284	memset(&src, 0, sizeof(src));
285	src.d_buf = buf + offset;
286	src.d_size = len;
287	src.d_type = ELF_T_NOTE;
288	src.d_version = EV_CURRENT;
289
290	memset(&dst, 0, sizeof(dst));
291	dst.d_buf = copy = malloc(len);
292	dst.d_size = len;
293	dst.d_type = ELF_T_NOTE;
294	dst.d_version = EV_CURRENT;
295
296	if (gelf_xlatetom(elf, &dst, &src, ehdr->e_ident[EI_DATA]) == NULL) {
297		warnx("%s: failed to parse notes: %s", fname, elf_errmsg(0));
298		free(copy);
299		return (false);
300	}
301
302	buf = copy;
303	has_abi_tag = false;
304	for (;;) {
305		if (len < sizeof(*note))
306			break;
307
308		note = (const void *)buf;
309		buf += sizeof(*note);
310		len -= sizeof(*note);
311
312		namesz = roundup2(note->n_namesz, sizeof(uint32_t));
313		descsz = roundup2(note->n_descsz, sizeof(uint32_t));
314		if (len < namesz + descsz)
315			break;
316
317		name = buf;
318		if (note->n_namesz == sizeof(ELF_NOTE_FREEBSD) &&
319		    strncmp(name, ELF_NOTE_FREEBSD, note->n_namesz) == 0 &&
320		    note->n_type == NT_FREEBSD_ABI_TAG &&
321		    note->n_descsz == sizeof(uint32_t)) {
322			has_abi_tag = true;
323			break;
324		}
325
326		buf += namesz + descsz;
327		len -= namesz + descsz;
328	}
329
330	free(copy);
331	return (has_abi_tag);
332}
333
334static bool
335is_pie(const char *fname, Elf *elf, GElf_Ehdr *ehdr, off_t offset, size_t len)
336{
337	Elf_Data dst, src;
338	char *buf;
339	void *copy;
340	const GElf_Dyn *dyn;
341	size_t dynsize;
342	u_int count, i;
343	bool pie;
344
345	buf = elf_rawfile(elf, NULL);
346	if (buf == NULL) {
347		warnx("%s: %s", fname, elf_errmsg(0));
348		return (false);
349	}
350
351	dynsize = gelf_fsize(elf, ELF_T_DYN, 1, EV_CURRENT);
352	if (dynsize == 0) {
353		warnx("%s: %s", fname, elf_errmsg(0));
354		return (false);
355	}
356	count = len / dynsize;
357
358	memset(&src, 0, sizeof(src));
359	src.d_buf = buf + offset;
360	src.d_size = len;
361	src.d_type = ELF_T_DYN;
362	src.d_version = EV_CURRENT;
363
364	memset(&dst, 0, sizeof(dst));
365	dst.d_buf = copy = malloc(count * sizeof(*dyn));
366	dst.d_size = count * sizeof(*dyn);
367	dst.d_type = ELF_T_DYN;
368	dst.d_version = EV_CURRENT;
369
370	if (gelf_xlatetom(elf, &dst, &src, ehdr->e_ident[EI_DATA]) == NULL) {
371		warnx("%s: failed to parse .dynamic: %s", fname, elf_errmsg(0));
372		free(copy);
373		return (false);
374	}
375
376	dyn = copy;
377	pie = false;
378	for (i = 0; i < count; i++) {
379		if (dyn[i].d_tag != DT_FLAGS_1)
380			continue;
381
382		pie = (dyn[i].d_un.d_val & DF_1_PIE) != 0;
383		break;
384	}
385
386	free(copy);
387	return (pie);
388}
389
390static int
391is_executable(const char *fname, int fd, int *is_shlib, int *type)
392{
393	Elf *elf;
394	GElf_Ehdr ehdr;
395	GElf_Phdr phdr;
396	bool dynamic, freebsd, pie;
397	int i;
398
399	*is_shlib = 0;
400	*type = TYPE_UNKNOWN;
401	dynamic = false;
402	freebsd = false;
403	pie = false;
404
405	if (elf_version(EV_CURRENT) == EV_NONE) {
406		warnx("unsupported libelf");
407		return (0);
408	}
409	elf = elf_begin(fd, ELF_C_READ, NULL);
410	if (elf == NULL) {
411		warnx("%s: %s", fname, elf_errmsg(0));
412		return (0);
413	}
414	if (elf_kind(elf) != ELF_K_ELF) {
415		elf_end(elf);
416		warnx("%s: not a dynamic ELF executable", fname);
417		return (0);
418	}
419	if (gelf_getehdr(elf, &ehdr) == NULL) {
420		warnx("%s: %s", fname, elf_errmsg(0));
421		elf_end(elf);
422		return (0);
423	}
424
425	*type = TYPE_ELF;
426#if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
427	if (gelf_getclass(elf) == ELFCLASS32) {
428		*type = TYPE_ELF32;
429	}
430#endif
431
432	freebsd = ehdr.e_ident[EI_OSABI] == ELFOSABI_FREEBSD;
433	for (i = 0; i < ehdr.e_phnum; i++) {
434		if (gelf_getphdr(elf, i, &phdr) == NULL) {
435			warnx("%s: %s", fname, elf_errmsg(0));
436			elf_end(elf);
437			return (0);
438		}
439		switch (phdr.p_type) {
440		case PT_NOTE:
441			if (ehdr.e_ident[EI_OSABI] == ELFOSABI_NONE && !freebsd)
442				freebsd = has_freebsd_abi_tag(fname, elf, &ehdr,
443				    phdr.p_offset, phdr.p_filesz);
444			break;
445		case PT_DYNAMIC:
446			dynamic = true;
447			if (ehdr.e_type == ET_DYN)
448				pie = is_pie(fname, elf, &ehdr, phdr.p_offset,
449				    phdr.p_filesz);
450			break;
451		}
452	}
453
454	if (!dynamic) {
455		elf_end(elf);
456		warnx("%s: not a dynamic ELF executable", fname);
457		return (0);
458	}
459
460	if (ehdr.e_type == ET_DYN && !pie) {
461		*is_shlib = 1;
462
463		if (!freebsd) {
464			elf_end(elf);
465			warnx("%s: not a FreeBSD ELF shared object", fname);
466			return (0);
467		}
468	}
469
470	elf_end(elf);
471	return (1);
472}
473