/*      $OpenBSD: ldd.c,v 1.26 2023/08/15 13:50:53 deraadt Exp $        */
/*
 * Copyright (c) 2001 Artur Grabowski <art@openbsd.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <elf.h>
#include <err.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <limits.h>
#include <dlfcn.h>
#include <errno.h>

#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/wait.h>

int usage(void);
int doit(char *);

int
main(int argc, char **argv)
{
        int c, xflag, ret;

        if (pledge("stdio rpath proc exec prot_exec", NULL) == -1)
                err(1, "pledge");

        xflag = 0;
        while ((c = getopt(argc, argv, "x")) != -1) {
                switch (c) {
                case 'x':
                        xflag = 1;
                        break;
                default:
                        usage();
                        /*NOTREACHED*/
                }
        }

        if (xflag)
                errx(1, "-x not yet implemented");

        argc -= optind;
        argv += optind;

        if (argc == 0)
                usage();

        if (setenv("LD_TRACE_LOADED_OBJECTS", "true", 1) < 0)
                err(1, "setenv(LD_TRACE_LOADED_OBJECTS)");

        ret = 0;
        while (argc--) {
                ret |= doit(*argv);
                argv++;
        }

        return ret;
}

int
usage(void)
{
        extern char *__progname;

        fprintf(stderr, "usage: %s program ...\n", __progname);
        exit(1);
}


int
doit(char *name)
{
        Elf_Ehdr ehdr;
        Elf_Phdr *phdr;
        size_t size;
        int fd, i, status, interp=0;
        char buf[PATH_MAX];
        struct stat st;
        void * dlhandle;

        if ((fd = open(name, O_RDONLY)) < 0) {
                warn("%s", name);
                return 1;
        }

        if (fstat(fd, &st) == -1) {
                warn("%s", name);
                close(fd);
                return 1;
        }

        if (!S_ISREG(st.st_mode)) {
                warnx("%s: not a regular file", name);
                close(fd);
                return 1;
        }

        if (read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) {
                warnx("%s: incomplete ELF header", name);
                close(fd);
                return 1;
        }

        if (!IS_ELF(ehdr) || ehdr.e_machine != ELF_TARG_MACH) {
                warnx("%s: not an ELF executable", name);
                close(fd);
                return 1;
        }

        if (ehdr.e_phnum == 0 || ehdr.e_phentsize == 0) {
                warnx("%s: missing program header", name);
                close(fd);
                return 1;
        }

        if ((phdr = reallocarray(NULL, ehdr.e_phnum, sizeof(Elf_Phdr))) == NULL)
                err(1, "reallocarray");
        size = ehdr.e_phnum * sizeof(Elf_Phdr);

        if (pread(fd, phdr, size, ehdr.e_phoff) != size) {
                warnx("%s: incomplete program header", name);
                close(fd);
                free(phdr);
                return 1;
        }
        close(fd);

        for (i = 0; i < ehdr.e_phnum; i++)
                if (phdr[i].p_type == PT_INTERP) {
                        interp = 1;
                        break;
                }
        free(phdr);

        printf("%s:\n", name);
        fflush(stdout);
        switch (fork()) {
        case -1:
                err(1, "fork");
        case 0:
                if (ehdr.e_type == ET_DYN && !interp) {
                        if (pledge("stdio rpath prot_exec", NULL) == -1)
                                err(1, "pledge");
                        if (realpath(name, buf) == NULL) {
                                printf("realpath(%s): %s", name,
                                    strerror(errno));
                                fflush(stdout);
                                _exit(1);
                        }
                        dlhandle = dlopen(buf, RTLD_TRACE);
                        if (dlhandle == NULL) {
                                printf("%s\n", dlerror());
                                fflush(stdout);
                                _exit(1);
                        }
                        _exit(0);
                }

                if (pledge("stdio rpath exec", "stdio rpath") == -1)
                        err(1, "pledge");
                if (i == ehdr.e_phnum) {
                        printf("not a dynamic executable\n");
                        fflush(stdout);
                        _exit(0);
                }
                execl(name, name, (char *)NULL);
                perror(name);
                _exit(1);
        default:
                if (wait(&status) < 0) {
                        warn("wait");
                        return 1;
                }
                if (WIFSIGNALED(status)) {
                        if (WTERMSIG(status) == SIGINT)
                                return 1;
                        fprintf(stderr, "%s: signal %d\n", name,
                            WTERMSIG(status));
                        return 1;
                }
                if (WEXITSTATUS(status)) {
                        fprintf(stderr, "%s: exit status %d\n", name,
                            WEXITSTATUS(status));
                        return 1;
                }
        }

        return 0;
}