usr.bin/ldd/ldd.c

   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 <rtld_paths.h>
  50 #include <stdbool.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <unistd.h>
  55
  56 /*
  57  * 32-bit ELF data structures can only be used if the system header[s] declare
  58  * them.  There is no official macro for determining whether they are declared,
  59  * so check for the existence of one of the 32-macros defined in elf(5).
  60  */
  61 #ifdef ELF32_R_TYPE
  62 #define ELF32_SUPPORTED
  63 #endif
  64
  65 #define LDD_SETENV(name, value, overwrite) do {         \
  66         setenv("LD_" name, value, overwrite);           \
  67         setenv("LD_32_" name, value, overwrite);        \
  68 } while (0)
  69
  70 #define LDD_UNSETENV(name) do {         \
  71         unsetenv("LD_" name);           \
  72         unsetenv("LD_32_" name);        \
  73 } while (0)
  74
  75 static int      is_executable(const char *fname, int fd, int *is_shlib,
  76                     int *type);
  77 static void     usage(void);
  78
  79 #define TYPE_UNKNOWN    0
  80 #define TYPE_ELF        1       /* Architecture default */
  81 #if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
  82 #define TYPE_ELF32      2       /* Explicit 32 bits on architectures >32 bits */
  83
  84 #define _PATH_LDD32     "/usr/bin/ldd32"
  85
  86 static int
  87 execldd32(char *file, char *fmt1, char *fmt2, int aflag)
  88 {
  89         char *argv[9];
  90         int i, rval, status;
  91
  92         LDD_UNSETENV("TRACE_LOADED_OBJECTS");
  93         rval = 0;
  94         i = 0;
  95         argv[i++] = strdup(_PATH_LDD32);
  96         if (aflag)
  97                 argv[i++] = strdup("-a");
  98         if (fmt1 != NULL) {
  99                 argv[i++] = strdup("-f");
 100                 argv[i++] = strdup(fmt1);
 101         }
 102         if (fmt2 != NULL) {
 103                 argv[i++] = strdup("-f");
 104                 argv[i++] = strdup(fmt2);
 105         }
 106         argv[i++] = strdup(file);
 107         argv[i++] = NULL;
 108
 109         switch (fork()) {
 110         case -1:
 111                 err(1, "fork");
 112                 break;
 113         case 0:
 114                 execv(_PATH_LDD32, argv);
 115                 warn("%s", _PATH_LDD32);
 116                 _exit(127);
 117                 break;
 118         default:
 119                 if (wait(&status) < 0)
 120                         rval = 1;
 121                 else if (WIFSIGNALED(status))
 122                         rval = 1;
 123                 else if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
 124                         rval = 1;
 125                 break;
 126         }
 127         while (i--)
 128                 free(argv[i]);
 129         LDD_SETENV("TRACE_LOADED_OBJECTS", "yes", 1);
 130         return (rval);
 131 }
 132 #endif
 133
 134 int
 135 main(int argc, char *argv[])
 136 {
 137         char *fmt1, *fmt2;
 138         const char *rtld;
 139         int aflag, c, fd, rval, status, is_shlib, rv, type;
 140
 141         aflag = 0;
 142         fmt1 = fmt2 = NULL;
 143
 144         while ((c = getopt(argc, argv, "af:")) != -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                 default:
 158                         usage();
 159                         /* NOTREACHED */
 160                 }
 161         }
 162         argc -= optind;
 163         argv += optind;
 164
 165         if (argc <= 0) {
 166                 usage();
 167                 /* NOTREACHED */
 168         }
 169
 170         rval = 0;
 171         for (; argc > 0; argc--, argv++) {
 172                 if ((fd = open(*argv, O_RDONLY | O_VERIFY, 0)) < 0) {
 173                         warn("%s", *argv);
 174                         rval |= 1;
 175                         continue;
 176                 }
 177                 rv = is_executable(*argv, fd, &is_shlib, &type);
 178                 close(fd);
 179                 if (rv == 0) {
 180                         rval |= 1;
 181                         continue;
 182                 }
 183
 184                 switch (type) {
 185                 case TYPE_ELF:
 186                         break;
 187 #if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
 188                 case TYPE_ELF32:
 189                         rval |= execldd32(*argv, fmt1, fmt2, aflag);
 190                         continue;
 191 #endif
 192                 case TYPE_UNKNOWN:
 193                 default:
 194                         /*
 195                          * This shouldn't happen unless is_executable()
 196                          * is broken.
 197                          */
 198                         errx(EDOOFUS, "unknown executable type");
 199                 }
 200
 201                 /* ld.so magic */
 202                 LDD_SETENV("TRACE_LOADED_OBJECTS", "yes", 1);
 203                 if (fmt1 != NULL)
 204                         LDD_SETENV("TRACE_LOADED_OBJECTS_FMT1", fmt1, 1);
 205                 if (fmt2 != NULL)
 206                         LDD_SETENV("TRACE_LOADED_OBJECTS_FMT2", fmt2, 1);
 207
 208                 LDD_SETENV("TRACE_LOADED_OBJECTS_PROGNAME", *argv, 1);
 209                 if (aflag)
 210                         LDD_SETENV("TRACE_LOADED_OBJECTS_ALL", "1", 1);
 211                 else if (fmt1 == NULL && fmt2 == NULL)
 212                         /* Default formats */
 213                         printf("%s:\n", *argv);
 214                 fflush(stdout);
 215
 216                 switch (fork()) {
 217                 case -1:
 218                         err(1, "fork");
 219                         break;
 220                 default:
 221                         if (wait(&status) < 0) {
 222                                 warn("wait");
 223                                 rval |= 1;
 224                         } else if (WIFSIGNALED(status)) {
 225                                 fprintf(stderr, "%s: signal %d\n", *argv,
 226                                     WTERMSIG(status));
 227                                 rval |= 1;
 228                         } else if (WIFEXITED(status) &&
 229                             WEXITSTATUS(status) != 0) {
 230                                 fprintf(stderr, "%s: exit status %d\n", *argv,
 231                                     WEXITSTATUS(status));
 232                                 rval |= 1;
 233                         }
 234                         break;
 235                 case 0:
 236                         rtld = _PATH_RTLD;
 237 #if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
 238                         if (type == TYPE_ELF32)
 239                                 rtld = _COMPAT32_PATH_RTLD;
 240 #endif
 241                         if (is_shlib == 0) {
 242                                 execl(rtld, rtld, "--",
 243                                     *argv, (char *)NULL);
 244                                 warn("%s", *argv);
 245                         } else if (fmt1 == NULL && fmt2 == NULL && !aflag) {
 246                                 dlopen(*argv, RTLD_TRACE);
 247                                 warnx("%s: %s", *argv, dlerror());
 248                         } else {
 249                                 execl(rtld, rtld, "-d", "--",
 250                                     *argv, (char *)NULL);
 251                         }
 252                         _exit(1);
 253                 }
 254         }
 255
 256         return (rval);
 257 }
 258
 259 static void
 260 usage(void)
 261 {
 262
 263         fprintf(stderr, "usage: ldd [-a] [-f format] program ...\n");
 264         exit(1);
 265 }
 266
 267 static bool
 268 has_freebsd_abi_tag(const char *fname, Elf *elf, GElf_Ehdr *ehdr, off_t offset,
 269     size_t len)
 270 {
 271         Elf_Data dst, src;
 272         const Elf_Note *note;
 273         char *buf;
 274         const char *name;
 275         void *copy;
 276         size_t namesz, descsz;
 277         bool has_abi_tag;
 278
 279         buf = elf_rawfile(elf, NULL);
 280         if (buf == NULL) {
 281                 warnx("%s: %s", fname, elf_errmsg(0));
 282                 return (false);
 283         }
 284
 285         memset(&src, 0, sizeof(src));
 286         src.d_buf = buf + offset;
 287         src.d_size = len;
 288         src.d_type = ELF_T_NOTE;
 289         src.d_version = EV_CURRENT;
 290
 291         memset(&dst, 0, sizeof(dst));
 292         dst.d_buf = copy = malloc(len);
 293         dst.d_size = len;
 294         dst.d_type = ELF_T_NOTE;
 295         dst.d_version = EV_CURRENT;
 296
 297         if (gelf_xlatetom(elf, &dst, &src, ehdr->e_ident[EI_DATA]) == NULL) {
 298                 warnx("%s: failed to parse notes: %s", fname, elf_errmsg(0));
 299                 free(copy);
 300                 return (false);
 301         }
 302
 303         buf = copy;
 304         has_abi_tag = false;
 305         for (;;) {
 306                 if (len < sizeof(*note))
 307                         break;
 308
 309                 note = (const void *)buf;
 310                 buf += sizeof(*note);
 311                 len -= sizeof(*note);
 312
 313                 namesz = roundup2(note->n_namesz, sizeof(uint32_t));
 314                 descsz = roundup2(note->n_descsz, sizeof(uint32_t));
 315                 if (len < namesz + descsz)
 316                         break;
 317
 318                 name = buf;
 319                 if (note->n_namesz == sizeof(ELF_NOTE_FREEBSD) &&
 320                     strncmp(name, ELF_NOTE_FREEBSD, note->n_namesz) == 0 &&
 321                     note->n_type == NT_FREEBSD_ABI_TAG &&
 322                     note->n_descsz == sizeof(uint32_t)) {
 323                         has_abi_tag = true;
 324                         break;
 325                 }
 326
 327                 buf += namesz + descsz;
 328                 len -= namesz + descsz;
 329         }
 330
 331         free(copy);
 332         return (has_abi_tag);
 333 }
 334
 335 static bool
 336 is_pie(const char *fname, Elf *elf, GElf_Ehdr *ehdr, off_t offset, size_t len)
 337 {
 338         Elf_Data dst, src;
 339         char *buf;
 340         void *copy;
 341         const GElf_Dyn *dyn;
 342         size_t dynsize;
 343         u_int count, i;
 344         bool pie;
 345
 346         buf = elf_rawfile(elf, NULL);
 347         if (buf == NULL) {
 348                 warnx("%s: %s", fname, elf_errmsg(0));
 349                 return (false);
 350         }
 351
 352         dynsize = gelf_fsize(elf, ELF_T_DYN, 1, EV_CURRENT);
 353         if (dynsize == 0) {
 354                 warnx("%s: %s", fname, elf_errmsg(0));
 355                 return (false);
 356         }
 357         count = len / dynsize;
 358
 359         memset(&src, 0, sizeof(src));
 360         src.d_buf = buf + offset;
 361         src.d_size = len;
 362         src.d_type = ELF_T_DYN;
 363         src.d_version = EV_CURRENT;
 364
 365         memset(&dst, 0, sizeof(dst));
 366         dst.d_buf = copy = malloc(count * sizeof(*dyn));
 367         dst.d_size = count * sizeof(*dyn);
 368         dst.d_type = ELF_T_DYN;
 369         dst.d_version = EV_CURRENT;
 370
 371         if (gelf_xlatetom(elf, &dst, &src, ehdr->e_ident[EI_DATA]) == NULL) {
 372                 warnx("%s: failed to parse .dynamic: %s", fname, elf_errmsg(0));
 373                 free(copy);
 374                 return (false);
 375         }
 376
 377         dyn = copy;
 378         pie = false;
 379         for (i = 0; i < count; i++) {
 380                 if (dyn[i].d_tag != DT_FLAGS_1)
 381                         continue;
 382
 383                 pie = (dyn[i].d_un.d_val & DF_1_PIE) != 0;
 384                 break;
 385         }
 386
 387         free(copy);
 388         return (pie);
 389 }
 390
 391 static int
 392 is_executable(const char *fname, int fd, int *is_shlib, int *type)
 393 {
 394         Elf *elf;
 395         GElf_Ehdr ehdr;
 396         GElf_Phdr phdr;
 397         bool dynamic, freebsd, pie;
 398         int i;
 399
 400         *is_shlib = 0;
 401         *type = TYPE_UNKNOWN;
 402         dynamic = false;
 403         freebsd = false;
 404         pie = false;
 405
 406         if (elf_version(EV_CURRENT) == EV_NONE) {
 407                 warnx("unsupported libelf");
 408                 return (0);
 409         }
 410         elf = elf_begin(fd, ELF_C_READ, NULL);
 411         if (elf == NULL) {
 412                 warnx("%s: %s", fname, elf_errmsg(0));
 413                 return (0);
 414         }
 415         if (elf_kind(elf) != ELF_K_ELF) {
 416                 elf_end(elf);
 417                 warnx("%s: not a dynamic ELF executable", fname);
 418                 return (0);
 419         }
 420         if (gelf_getehdr(elf, &ehdr) == NULL) {
 421                 warnx("%s: %s", fname, elf_errmsg(0));
 422                 elf_end(elf);
 423                 return (0);
 424         }
 425
 426         *type = TYPE_ELF;
 427 #if __ELF_WORD_SIZE > 32 && defined(ELF32_SUPPORTED)
 428         if (gelf_getclass(elf) == ELFCLASS32) {
 429                 *type = TYPE_ELF32;
 430         }
 431 #endif
 432
 433         freebsd = ehdr.e_ident[EI_OSABI] == ELFOSABI_FREEBSD;
 434         for (i = 0; i < ehdr.e_phnum; i++) {
 435                 if (gelf_getphdr(elf, i, &phdr) == NULL) {
 436                         warnx("%s: %s", fname, elf_errmsg(0));
 437                         elf_end(elf);
 438                         return (0);
 439                 }
 440                 switch (phdr.p_type) {
 441                 case PT_NOTE:
 442                         if (ehdr.e_ident[EI_OSABI] == ELFOSABI_NONE && !freebsd)
 443                                 freebsd = has_freebsd_abi_tag(fname, elf, &ehdr,
 444                                     phdr.p_offset, phdr.p_filesz);
 445                         break;
 446                 case PT_DYNAMIC:
 447                         dynamic = true;
 448                         if (ehdr.e_type == ET_DYN)
 449                                 pie = is_pie(fname, elf, &ehdr, phdr.p_offset,
 450                                     phdr.p_filesz);
 451                         break;
 452                 }
 453         }
 454
 455         if (!dynamic) {
 456                 elf_end(elf);
 457                 warnx("%s: not a dynamic ELF executable", fname);
 458                 return (0);
 459         }
 460
 461         if (ehdr.e_type == ET_DYN && !pie) {
 462                 *is_shlib = 1;
 463
 464                 if (!freebsd) {
 465                         elf_end(elf);
 466                         warnx("%s: not a FreeBSD ELF shared object", fname);
 467                         return (0);
 468                 }
 469         }
 470
 471         elf_end(elf);
 472         return (1);
 473 }