/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2024 Oxide Computer Company
 */

/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */

/*
 *      execlp(name, arg,...,0) (like execl, but does path search)
 *      execvp(name, argv)      (like execv, but does path search)
 *      execvpe(name, argv, envp) (like execve, but does path search)
 */

#pragma weak _execlp = execlp
#pragma weak _execvp = execvp

#include "lint.h"
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <alloca.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>
#include <paths.h>

static const char *execat(const char *, const char *, char *);

extern  int __xpg4;     /* defined in xpg4.c; 0 if not xpg4-compiled program */

/*VARARGS1*/
int
execlp(const char *name, const char *arg0, ...)
{
        char **argp;
        va_list args;
        char **argvec;
        int err;
        int nargs = 0;
        char *nextarg;

        /*
         * count the number of arguments in the variable argument list
         * and allocate an argument vector for them on the stack,
         * adding space for a terminating null pointer at the end
         * and one additional space for argv[0] which is no longer
         * counted by the varargs loop.
         */

        va_start(args, arg0);

        while (va_arg(args, char *) != (char *)0)
                nargs++;

        va_end(args);

        /*
         * load the arguments in the variable argument list
         * into the argument vector and add the terminating null pointer
         */

        va_start(args, arg0);
        /* workaround for bugid 1242839 */
        argvec = alloca((size_t)((nargs + 2) * sizeof (char *)));
        nextarg = va_arg(args, char *);
        argp = argvec;
        *argp++ = (char *)arg0;
        while (nargs-- && nextarg != (char *)0) {
                *argp = nextarg;
                argp++;
                nextarg = va_arg(args, char *);
        }
        va_end(args);
        *argp = (char *)0;

        /*
         * call execvp()
         */

        err = execvp(name, argvec);
        return (err);
}

static int
execvpe_int(const char *name, char *const *argv, char *const *envp,
    boolean_t use_env)
{
        const char      *pathstr;
        char    fname[PATH_MAX+2];
        char    *newargs[256];
        int     i;
        const char *cp;
        unsigned etxtbsy = 1;
        int eacces = 0;

        if (*name == '\0') {
                errno = ENOENT;
                return (-1);
        }
        if ((pathstr = getenv("PATH")) == NULL) {
                /*
                 * XPG4:  pathstr is equivalent to CSPATH, except that
                 * :/usr/sbin is appended when root, and pathstr must end
                 * with a colon when not root.  Keep these paths in sync
                 * with CSPATH in confstr.c.  Note that pathstr must end
                 * with a colon when not root so that when name doesn't
                 * contain '/', the last call to execat() will result in an
                 * attempt to execv name from the current directory.
                 */
                if (geteuid() == 0 || getuid() == 0) {
                        if (__xpg4 == 0) {      /* not XPG4 */
                                pathstr = "/usr/sbin:/usr/ccs/bin:/usr/bin";
                        } else {                /* XPG4 (CSPATH + /usr/sbin) */
                                pathstr = "/usr/xpg4/bin:/usr/ccs/bin:/usr/bin:"
                                    "/opt/SUNWspro/bin:/usr/sbin";
                        }
                } else {
                        if (__xpg4 == 0) {      /* not XPG4 */
                                pathstr = "/usr/ccs/bin:/usr/bin:";
                        } else {                /* XPG4 (CSPATH) */
                                pathstr = "/usr/xpg4/bin:/usr/ccs/bin:"
                                    "/usr/bin:/opt/SUNWspro/bin:";
                        }
                }
        }
        cp = strchr(name, '/')? (const char *)"": pathstr;

        do {
                cp = execat(cp, name, fname);
        retry:
                /*
                 * 4025035 and 4038378
                 * if a filename begins with a "-" prepend "./" so that
                 * the shell can't interpret it as an option
                 */
                if (*fname == '-') {
                        size_t size = strlen(fname) + 1;
                        if ((size + 2) > sizeof (fname)) {
                                errno = E2BIG;
                                return (-1);
                        }
                        (void) memmove(fname + 2, fname, size);
                        fname[0] = '.';
                        fname[1] = '/';
                }
                if (use_env) {
                        (void) execve(fname, argv, envp);
                } else {
                        (void) execv(fname, argv);
                }
                switch (errno) {
                case ENOEXEC:
                        newargs[0] = "sh";
                        newargs[1] = fname;
                        for (i = 1; (newargs[i + 1] = argv[i]) != NULL; ++i) {
                                if (i >= 254) {
                                        errno = E2BIG;
                                        return (-1);
                                }
                        }
                        if (use_env) {
                                (void) execve(_PATH_BSHELL, newargs, envp);
                        } else {
                                (void) execv(_PATH_BSHELL, newargs);
                        }
                        return (-1);
                case ETXTBSY:
                        if (++etxtbsy > 5)
                                return (-1);
                        (void) sleep(etxtbsy);
                        goto retry;
                case EACCES:
                        ++eacces;
                        break;
                case ENOMEM:
                case E2BIG:
                case EFAULT:
                        return (-1);
                }
        } while (cp);
        if (eacces)
                errno = EACCES;
        return (-1);
}

int
execvp(const char *file, char *const *argv)
{
        return (execvpe_int(file, argv, NULL, B_FALSE));
}

int
execvpe(const char *file, char *const *argv, char *const *envp)
{
        return (execvpe_int(file, argv, envp, B_TRUE));
}

static const char *
execat(const char *s1, const char *s2, char *si)
{
        char    *s;
        int cnt = PATH_MAX + 1; /* number of characters in s2 */

        s = si;
        while (*s1 && *s1 != ':') {
                if (cnt > 0) {
                        *s++ = *s1++;
                        cnt--;
                } else
                        s1++;
        }
        if (si != s && cnt > 0) {
                *s++ = '/';
                cnt--;
        }
        while (*s2 && cnt > 0) {
                *s++ = *s2++;
                cnt--;
        }
        *s = '\0';
        return (*s1 ? ++s1: 0);
}