/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2011 by Delphix. All rights reserved.
 * Copyright 2026 Oxide Computer Company
 */

#include "lint.h"
#include "thr_uberdata.h"
#include <sys/sysmacros.h>
#include <limits.h>
#include <spawn.h>
#include <stdbool.h>
#include <sys/spawn_impl.h>
#include <paths.h>

extern const char **_environ;
extern int libc__xpg4;

extern pid_t __spawn(const char *, const void *, uint32_t, const void *,
    uint32_t);

/*
 * Add sz to the running total *lenp, refusing if the total would exceed
 * ARG_MAX. ARG_MAX is well below UINT32_MAX, so capping there also keeps the
 * marshalled totals and offsets within their uint32_t fields.
 */
static inline bool
spawn_addlen(size_t *lenp, size_t sz)
{
        if (sz > ARG_MAX - *lenp)
                return (false);
        *lenp += sz;
        return (true);
}

/*
 * Pack the argv[] and envp[] string vectors into sargs->sa_data as a single
 * blob of NUL-terminated strings. Called first with sargs == NULL to compute
 * the required buffer size, then again to populate the data and record the
 * offsets and counts. Returns false if the combined size would exceed ARG_MAX
 * or, on the second pass, would overflow the allocated buffer.
 */
static bool
spawn_marshal_argenv(spawn_args_t *sargs, char *const *argp, char *const *envp,
    size_t *lenp)
{
        struct vec {
                char *const *vec;
                uint32_t *off;
                uint32_t *cnt;
        } vecs[] = {
                { .vec = argp },
                { .vec = envp }
        };

        if (sargs != NULL) {
                vecs[0].off = &sargs->sa_arg_off;
                vecs[0].cnt = &sargs->sa_arg_cnt;
                vecs[1].off = &sargs->sa_env_off;
                vecs[1].cnt = &sargs->sa_env_cnt;
        }

        for (size_t i = 0; i < ARRAY_SIZE(vecs); i++) {
                struct vec *vec = &vecs[i];
                uint32_t cnt = 0;
                char *const *p;

                if (vec->off != NULL)
                        *vec->off = (uint32_t)*lenp;

                for (p = vec->vec; p != NULL && *p != NULL; p++) {
                        size_t sz = strlen(*p) + 1;

                        if (sargs != NULL) {
                                if (*lenp + sz > sargs->sa_datalen)
                                        return (false);
                                (void) memcpy(&sargs->sa_data[*lenp], *p, sz);
                        }
                        if (!spawn_addlen(lenp, sz))
                                return (false);
                        cnt++;
                }

                if (vec->cnt != NULL)
                        *vec->cnt = cnt;
        }

        return (true);
}

/*
 * Pack the spawn_attr_t, the resolved scheduling attributes, the circular
 * list of file_attr_t records and, for posix_spawnp(), the shell and search
 * path strings into sparam->sp_data.
 * Called first with sparam == NULL to compute the required buffer size, then
 * again to populate the data and record the offsets, lengths and counts.
 * Returns false if the combined size would exceed ARG_MAX or, on the second
 * pass, would overflow the allocated buffer.
 */
static bool
spawn_marshal_param(spawn_param_t *sparam, const spawn_attr_t *sa,
    const kspawn_sched_t *ksched, const file_attr_t *fa, const char *shell,
    const char *pathstr, size_t *lenp)
{
        if (sa != NULL) {
                size_t sz = sizeof (*sa);

                if (sparam != NULL) {
                        if (*lenp + sz > sparam->sp_datalen)
                                return (false);
                        sparam->sp_attr_off = (uint32_t)*lenp;
                        sparam->sp_attr_len = (uint32_t)sz;
                        (void) memcpy(&sparam->sp_data[*lenp], sa, sz);
                }
                if (!spawn_addlen(lenp, sz))
                        return (false);
        }

        if (ksched != NULL) {
                size_t sz = sizeof (*ksched);

                if (sparam != NULL) {
                        if (*lenp + sz > sparam->sp_datalen)
                                return (false);
                        sparam->sp_sched_off = (uint32_t)*lenp;
                        sparam->sp_sched_len = (uint32_t)sz;
                        (void) memcpy(&sparam->sp_data[*lenp], ksched, sz);
                }
                if (!spawn_addlen(lenp, sz))
                        return (false);
        }

        if (fa != NULL) {
                const file_attr_t *froot = fa;
                uint32_t cnt = 0;

                if (sparam != NULL)
                        sparam->sp_fattr_off = (uint32_t)*lenp;

                do {
                        /*
                         * Each record is padded so that the next remains
                         * 32-bit aligned.
                         */
                        size_t sz = P2ROUNDUP(
                            sizeof (kfile_attr_t) + fa->fa_pathsize,
                            sizeof (uint32_t));

                        if (sparam != NULL) {
                                kfile_attr_t *ka;

                                if (*lenp + sz > sparam->sp_datalen)
                                        return (false);

                                ka = (kfile_attr_t *)&sparam->sp_data[*lenp];
                                ka->kfa_len = sz;
                                ka->kfa_type = fa->fa_type;
                                ka->kfa_pathsize = fa->fa_pathsize;

                                switch (fa->fa_type) {
                                case FA_OPEN:
                                        ka->kfa_filedes = fa->fa_filedes;
                                        ka->kfa_oflag = fa->fa_oflag;
                                        ka->kfa_mode = fa->fa_mode;
                                        /* FALLTHROUGH */
                                case FA_CHDIR:
                                        (void) memcpy(ka->kfa_path,
                                            fa->fa_path, fa->fa_pathsize);
                                        break;
                                case FA_DUP2:
                                        ka->kfa_newfiledes = fa->fa_newfiledes;
                                        /* FALLTHROUGH */
                                case FA_CLOSE:
                                case FA_CLOSEFROM:
                                case FA_FCHDIR:
                                        ka->kfa_filedes = fa->fa_filedes;
                                        break;
                                }
                        }
                        if (!spawn_addlen(lenp, sz))
                                return (false);
                        cnt++;
                } while ((fa = fa->fa_next) != froot);

                if (sparam != NULL)
                        sparam->sp_fattr_cnt = cnt;
        }

        if (shell != NULL) {
                size_t sz = strlen(shell) + 1;

                if (sparam != NULL) {
                        if (*lenp + sz > sparam->sp_datalen)
                                return (false);
                        sparam->sp_shell_off = (uint32_t)*lenp;
                        sparam->sp_shell_len = (uint32_t)sz;
                        (void) memcpy(&sparam->sp_data[*lenp], shell, sz);
                }
                if (!spawn_addlen(lenp, sz))
                        return (false);
        }

        if (pathstr != NULL) {
                size_t sz = strlen(pathstr) + 1;

                if (sparam != NULL) {
                        if (*lenp + sz > sparam->sp_datalen)
                                return (false);
                        sparam->sp_path_off = (uint32_t)*lenp;
                        sparam->sp_path_len = (uint32_t)sz;
                        (void) memcpy(&sparam->sp_data[*lenp], pathstr, sz);
                }
                if (!spawn_addlen(lenp, sz))
                        return (false);
        }

        return (true);
}

static int
posix_spawn_common(pid_t *pidp, const char *path,
    const posix_spawn_file_actions_t *file_actions,
    const posix_spawnattr_t *attrp, char *const *argp, char *const *envp,
    const char *shell, const char *pathstr)
{
        spawn_attr_t *sa = (attrp != NULL) ? attrp->__spawn_attrp : NULL;
        file_attr_t *fa = (file_actions != NULL) ? file_actions->__file_attrp :
            NULL;
        const kspawn_sched_t *ksched = NULL;
        kspawn_sched_t ks;
        spawn_args_t *sargs = NULL;
        spawn_param_t *sparam = NULL;
        pid_t pid;
        size_t datalen, len;
        int ret = 0;

        if (attrp != NULL && sa == NULL)
                return (EINVAL);

        /*
         * The scheduling attributes are resolved here into the form that the
         * child applies to itself in the kernel.
         */
        if (sa != NULL && (sa->sa_psflags &
            (POSIX_SPAWN_SETSCHEDULER | POSIX_SPAWN_SETSCHEDPARAM)) != 0) {
                ret = spawn_sched_resolve(sa->sa_psflags, sa->sa_schedpolicy,
                    sa->sa_priority, &ks);
                if (ret != 0)
                        return (ret);
                ksched = &ks;
        }

        /*
         * spawn(2) creates a brand-new child process that does not share the
         * parent's address space, so every piece of state needed to set up the
         * child must be copied into the kernel ahead of time. Marshal the
         * spawn attributes, the list of file actions and, for posix_spawnp(),
         * the shell and search path, into a single contiguous blob that the
         * kernel can copy in and retain.
         */
        datalen = 0;
        if (!spawn_marshal_param(NULL, sa, ksched, fa, shell, pathstr,
            &datalen)) {
                ret = E2BIG;
                goto out;
        }
        if (datalen > 0) {
                len = sizeof (*sparam) + datalen;
                sparam = lmalloc(len);
                if (sparam == NULL) {
                        ret = errno;
                        goto out;
                }
                sparam->sp_size = len;
                sparam->sp_datalen = datalen;

                datalen = 0;
                if (!spawn_marshal_param(sparam, sa, ksched, fa, shell,
                    pathstr, &datalen) || datalen != sparam->sp_datalen) {
                        ret = EINVAL;
                        goto out;
                }
        }

        /*
         * Likewise the argument and environment vectors. As supplied by the
         * caller these are arrays of pointers into strings that may well be
         * scattered around the parent's address space. Flatten the strings
         * into a single contiguous blob that the kernel can copy in.
         */
        datalen = 0;
        if (!spawn_marshal_argenv(NULL, argp, envp, &datalen)) {
                ret = E2BIG;
                goto out;
        }
        len = sizeof (*sargs) + datalen;
        sargs = lmalloc(len);
        if (sargs == NULL) {
                ret = errno;
                goto out;
        }
        sargs->sa_size = len;
        sargs->sa_datalen = datalen;

        datalen = 0;
        if (!spawn_marshal_argenv(sargs, argp, envp, &datalen) ||
            datalen != sargs->sa_datalen) {
                ret = EINVAL;
                goto out;
        }

        pid = __spawn(path, sparam, sparam != NULL ? sparam->sp_size : 0,
            sargs, sargs->sa_size);

        if (pid == -1) {
                ret = errno;
                goto out;
        }

        if (pidp != NULL)
                *pidp = pid;

out:
        if (sparam != NULL)
                lfree(sparam, sparam->sp_size);
        if (sargs != NULL)
                lfree(sargs, sargs->sa_size);
        return (ret);
}

int
posix_spawn(pid_t *pidp, const char *path,
    const posix_spawn_file_actions_t *file_actions,
    const posix_spawnattr_t *attrp, char *const *argp, char *const *envp)
{
        return (posix_spawn_common(pidp, path, file_actions, attrp,
            argp, envp, NULL, NULL));
}

int
posix_spawnp(pid_t *pidp, const char *file,
    const posix_spawn_file_actions_t *file_actions,
    const posix_spawnattr_t *attrp, char *const *argp, char *const *envp)
{
        const char *pathstr =
            (strchr(file, '/') == NULL) ? getenv("PATH") : "";

        if (*file == '\0')
                return (EACCES);

        if (pathstr == NULL) {
                /*
                 * XPG4:  pathstr is equivalent to _CS_PATH, except that
                 * :/usr/sbin is appended when root, and pathstr must end
                 * with a colon when not root.  Keep these paths in sync
                 * with _CS_PATH in confstr.c.  Note that pathstr must end
                 * with a colon when not root so that when file doesn't
                 * contain '/', the last attempt will be to exec the file
                 * from the current directory.
                 */
                if (geteuid() == 0 || getuid() == 0) {
                        if (!libc__xpg4) {
                                pathstr = "/usr/sbin:/usr/ccs/bin:/usr/bin";
                        } else {
                                pathstr = "/usr/xpg4/bin:/usr/ccs/bin:"
                                    "/usr/bin:/opt/SUNWspro/bin:/usr/sbin";
                        }
                } else {
                        if (!libc__xpg4) {
                                pathstr = "/usr/ccs/bin:/usr/bin:";
                        } else {
                                pathstr = "/usr/xpg4/bin:/usr/ccs/bin:"
                                    "/usr/bin:/opt/SUNWspro/bin:";
                        }
                }
        }

        return (posix_spawn_common(pidp, file, file_actions, attrp,
            argp, envp, _PATH_BSHELL, pathstr));
}

int
posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions)
{
        file_actions->__file_attrp = NULL;
        return (0);
}

int
posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions)
{
        file_attr_t *froot = file_actions->__file_attrp;
        file_attr_t *fap;
        file_attr_t *next;

        if ((fap = froot) != NULL) {
                do {
                        next = fap->fa_next;
                        if (fap->fa_type == FA_OPEN || fap->fa_type == FA_CHDIR)
                                lfree(fap->fa_path, fap->fa_pathsize);
                        lfree(fap, sizeof (*fap));
                } while ((fap = next) != froot);
        }
        file_actions->__file_attrp = NULL;
        return (0);
}

static void
add_file_attr(posix_spawn_file_actions_t *file_actions, file_attr_t *fap)
{
        file_attr_t *froot = file_actions->__file_attrp;

        if (froot == NULL) {
                fap->fa_next = fap->fa_prev = fap;
                file_actions->__file_attrp = froot = fap;
        } else {
                fap->fa_next = froot;
                fap->fa_prev = froot->fa_prev;
                froot->fa_prev->fa_next = fap;
                froot->fa_prev = fap;
        }
}

int
posix_spawn_file_actions_addopen(
    posix_spawn_file_actions_t *restrict file_actions,
    int filedes, const char *restrict path, int oflag, mode_t mode)
{
        file_attr_t *fap;

        if (filedes < 0)
                return (EBADF);
        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);

        fap->fa_pathsize = strlen(path) + 1;
        if ((fap->fa_path = lmalloc(fap->fa_pathsize)) == NULL) {
                lfree(fap, sizeof (*fap));
                return (ENOMEM);
        }
        (void) memcpy(fap->fa_path, path, fap->fa_pathsize);

        fap->fa_type = FA_OPEN;
        fap->fa_oflag = oflag;
        fap->fa_mode = mode;
        fap->fa_filedes = filedes;
        add_file_attr(file_actions, fap);

        return (0);
}

int
posix_spawn_file_actions_addclose(
    posix_spawn_file_actions_t *restrict file_actions, int filedes)
{
        file_attr_t *fap;

        if (filedes < 0)
                return (EBADF);
        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);

        fap->fa_type = FA_CLOSE;
        fap->fa_filedes = filedes;
        add_file_attr(file_actions, fap);

        return (0);
}

int
posix_spawn_file_actions_adddup2(
    posix_spawn_file_actions_t *restrict file_actions,
    int filedes, int newfiledes)
{
        file_attr_t *fap;

        if (filedes < 0 || newfiledes < 0)
                return (EBADF);
        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);

        fap->fa_type = FA_DUP2;
        fap->fa_filedes = filedes;
        fap->fa_newfiledes = newfiledes;
        add_file_attr(file_actions, fap);

        return (0);
}

int
posix_spawn_file_actions_addclosefrom_np(
    posix_spawn_file_actions_t *restrict file_actions, int lowfiledes)
{
        file_attr_t *fap;

        if (lowfiledes < 0)
                return (EBADF);
        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);
        fap->fa_type = FA_CLOSEFROM;
        fap->fa_filedes = lowfiledes;
        add_file_attr(file_actions, fap);

        return (0);
}

int
posix_spawn_file_actions_addchdir(
    posix_spawn_file_actions_t *restrict file_actions,
    const char *restrict path)
{
        file_attr_t *fap;

        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);

        fap->fa_pathsize = strlen(path) + 1;
        if ((fap->fa_path = lmalloc(fap->fa_pathsize)) == NULL) {
                lfree(fap, sizeof (*fap));
                return (ENOMEM);
        }
        (void) memcpy(fap->fa_path, path, fap->fa_pathsize);

        fap->fa_type = FA_CHDIR;
        add_file_attr(file_actions, fap);

        return (0);
}

int
posix_spawn_file_actions_addchdir_np(
    posix_spawn_file_actions_t *restrict file_actions,
    const char *restrict path)
{
        return (posix_spawn_file_actions_addchdir(file_actions, path));
}

int
posix_spawn_file_actions_addfchdir(
    posix_spawn_file_actions_t *restrict file_actions, int fd)
{
        file_attr_t *fap;

        if (fd < 0)
                return (EBADF);
        if ((fap = lmalloc(sizeof (*fap))) == NULL)
                return (ENOMEM);
        fap->fa_type = FA_FCHDIR;
        fap->fa_filedes = fd;
        add_file_attr(file_actions, fap);
        return (0);
}

int
posix_spawn_file_actions_addfchdir_np(
    posix_spawn_file_actions_t *restrict file_actions, int fd)
{
        return (posix_spawn_file_actions_addfchdir(file_actions, fd));
}

int
posix_spawnattr_init(posix_spawnattr_t *attr)
{
        if ((attr->__spawn_attrp = lmalloc(sizeof (posix_spawnattr_t))) == NULL)
                return (ENOMEM);
        /*
         * Add default stuff here?
         */
        return (0);
}

int
posix_spawnattr_destroy(posix_spawnattr_t *attr)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        /*
         * deallocate stuff here?
         */
        lfree(sap, sizeof (*sap));
        attr->__spawn_attrp = NULL;
        return (0);
}

int
posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL ||
            (flags & ~ALL_POSIX_SPAWN_FLAGS))
                return (EINVAL);

        sap->sa_psflags = flags;
        return (0);
}

int
posix_spawnattr_getflags(const posix_spawnattr_t *attr, short *flags)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *flags = sap->sa_psflags;
        return (0);
}

int
posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        sap->sa_pgroup = pgroup;
        return (0);
}

int
posix_spawnattr_getpgroup(const posix_spawnattr_t *attr, pid_t *pgroup)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *pgroup = sap->sa_pgroup;
        return (0);
}

int
posix_spawnattr_setschedparam(posix_spawnattr_t *attr,
    const struct sched_param *schedparam)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        /*
         * Check validity?
         */
        sap->sa_priority = schedparam->sched_priority;
        return (0);
}

int
posix_spawnattr_getschedparam(const posix_spawnattr_t *attr,
    struct sched_param *schedparam)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        schedparam->sched_priority = sap->sa_priority;
        return (0);
}

int
posix_spawnattr_setschedpolicy(posix_spawnattr_t *attr, int schedpolicy)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL || schedpolicy == SCHED_SYS)
                return (EINVAL);

        /*
         * Cache the policy information for later use by posix_spawn().
         */
        if (get_info_by_policy(schedpolicy) == NULL)
                return (errno);

        sap->sa_schedpolicy = schedpolicy;
        return (0);
}

int
posix_spawnattr_getschedpolicy(const posix_spawnattr_t *attr, int *schedpolicy)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *schedpolicy = sap->sa_schedpolicy;
        return (0);
}

int
posix_spawnattr_setsigdefault(posix_spawnattr_t *attr,
    const sigset_t *sigdefault)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        sap->sa_sigdefault = *sigdefault;
        return (0);
}

int
posix_spawnattr_getsigdefault(const posix_spawnattr_t *attr,
    sigset_t *sigdefault)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *sigdefault = sap->sa_sigdefault;
        return (0);
}

int
posix_spawnattr_setsigignore_np(posix_spawnattr_t *attr,
    const sigset_t *sigignore)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        sap->sa_sigignore = *sigignore;
        return (0);
}

int
posix_spawnattr_getsigignore_np(const posix_spawnattr_t *attr,
    sigset_t *sigignore)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *sigignore = sap->sa_sigignore;
        return (0);
}

int
posix_spawnattr_setsigmask(posix_spawnattr_t *attr,
    const sigset_t *sigmask)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        sap->sa_sigmask = *sigmask;
        return (0);
}

int
posix_spawnattr_getsigmask(const posix_spawnattr_t *attr,
    sigset_t *sigmask)
{
        spawn_attr_t *sap = attr->__spawn_attrp;

        if (sap == NULL)
                return (EINVAL);

        *sigmask = sap->sa_sigmask;
        return (0);
}

/*
 * Spawn a process to run "sh -c <cmd>".  Return the child's pid (in
 * *pidp), and a file descriptor (in *fdp) for reading or writing to the
 * child process, depending on the 'write' argument.
 * Return 0 on success; otherwise return an error code.
 */
int
posix_spawn_pipe_np(pid_t *pidp, int *fdp,
    const char *cmd, boolean_t write,
    posix_spawn_file_actions_t *fact, posix_spawnattr_t *attr)
{
        int     p[2];
        int     myside, yourside, stdio;
        const char *shpath = _PATH_BSHELL;
        const char *argvec[4] = { "sh", "-c", cmd, NULL };
        int     error;

        if (pipe(p) < 0)
                return (errno);

        if (access(shpath, X_OK))       /* XPG4 Requirement: */
                shpath = "";            /* force child to fail immediately */

        if (write) {
                /*
                 * Data is read from p[0] and written to p[1].
                 * 'stdio' is the fd in the child process that should be
                 * connected to the pipe.
                 */
                myside = p[1];
                yourside = p[0];
                stdio = STDIN_FILENO;
        } else {
                myside = p[0];
                yourside = p[1];
                stdio = STDOUT_FILENO;
        }

        error = posix_spawn_file_actions_addclose(fact, myside);
        if (yourside != stdio) {
                if (error == 0) {
                        error = posix_spawn_file_actions_adddup2(fact,
                            yourside, stdio);
                }
                if (error == 0) {
                        error = posix_spawn_file_actions_addclose(fact,
                            yourside);
                }
        }

        if (error)
                return (error);
        error = posix_spawn(pidp, shpath, fact, attr,
            (char *const *)argvec, (char *const *)_environ);
        (void) close(yourside);
        if (error) {
                (void) close(myside);
                return (error);
        }

        *fdp = myside;
        return (0);
}