cmd/lpsched/exec.c

/*
 * 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 (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

#include <pwd.h>
#include <zone.h>
#if defined PS_FAULTED
#undef  PS_FAULTED
#endif /* PS_FAULTED */
#include <dial.h>

#include <stdlib.h>
#include "limits.h"
#include "stdarg.h"
#include "wait.h"
#include "dial.h"
#include "lpsched.h"
#include <syslog.h>
#include "tsol/label.h"

#define Done(EC,ERRNO)  done(((EC) << 8),ERRNO)

#define STRLCAT(dst, src, size) \
    if (strlcat((dst), (src), (size)) >= (size)) { \
        errno = EINVAL; \
        return (-1); \
    }

static MESG *       ChildMd;

static int      ChildPid;
static int      WaitedChildPid;
static int      do_undial;

static char     argbuf[ARG_MAX];

static long     key;

static void     sigtrap ( int );
static void     done ( int , int );
static void     cool_heels ( void );
static void     addenv (char ***envp, char * , char * );
static void     trap_fault_signals ( void );
static void     ignore_fault_signals ( void );
static void     child_mallocfail ( void );
static void     Fork2 ( void );

static int      Fork1 ( EXEC * );

static void
relock(void)
{
    struct flock        l;

    l.l_type = F_WRLCK;
    l.l_whence = 1;
    l.l_start = 0;
    l.l_len = 0;
    (void)Fcntl (lock_fd, F_SETLK, &l);
    return;
}

static char *_exec_name(int type)
{
    static char *_names[] = {
    "", "EX_INTERF", "EX_SLOWF", "EX_ALERT", "EX_FALERT", "EX_PALERT",
    "EX_NOTIFY", "EX_FAULT_MESSAGE", "EX_FORM_MESSAGE", NULL };

    if ((type < 0) || (type > EX_FORM_MESSAGE))
        return ("BAD_EXEC_TYPE");
    else
        return (_names[type]);
}

/*
 * This function replaces characters in a string that might be used
 * to exploit a security hole.  Replace command seperators (`, &, ;, |, ^),
 * output redirection (>, |), variable expansion ($), and character
 * escape (\).
 *
 * Bugid 4141687
 * Add ( ) < * ? [
 * Bugid 4139071
 * Remove \
 */
void clean_string(char *ptr)
{
    char *cp;
    wchar_t wc;
    size_t len;

    for (cp = ptr; *cp != NULL; ) {
        if ((len = mbtowc(&wc, cp, MB_CUR_MAX)) == -1) {
            cp++;
            continue;
        }

        if (len == 1 &&
            ((wc == L'`') || (wc == L'&') || (wc == L';') ||
            (wc == L'|') || (wc == L'>') || (wc == L'^') ||
            (wc == L'$') || (wc == L'(') || (wc == L')') ||
            (wc == L'<') || (wc == L'*') || (wc == L'?') ||
            (wc == L'[')))
            *cp = '_';
        cp += len;
    }
}

enum trust {TRUSTED, UNTRUSTED};

static char *arg_string(enum trust type, char *fmt, ...) __PRINTFLIKE(2);

/* PRINTFLIKE2 */
static char *
arg_string(enum trust type, char *fmt, ...)
{
    char buf[BUFSIZ];
    va_list args;

    va_start(args, fmt);
    (void) vsnprintf(buf, sizeof(buf), fmt, args);
    va_end(args);

    /*
     * If the string contains data from an untrusted origin (user supplied),
     * clean it up in case one of our progeny is a shell script and isn't
     * careful about checking its input.
     */
    if (type == UNTRUSTED)
        clean_string(buf);

    return (strdup(buf));
}

/* stolen from libc/gen/port/gen/execvp.c */
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);
}

/*
 * Similiar to execvp(), execpt you can supply an environment and we always
 * use /bin/sh for shell scripts.  The PATH searched is the PATH in the
 * current environment, not the environment in the argument list.
 * This was pretty much stolen from libc/gen/port/execvp.c
 */
static int
execvpe(char *name, char *const argv[], char *const envp[])
{
    char *path;
    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 ((path = getenv("PATH")) == NULL)
        path = "/usr/bin:/bin";

        cp = strchr(name, '/')? (const char *)"": path;

        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] = '/';
                }
                (void) execve(fname, argv, envp);
                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);
                                }
                        }
                        (void) execve("/bin/sh", newargs, envp);
                        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);
}

static char time_buf[50];

/**
 ** exec() - FORK AND EXEC CHILD PROCESS
 **/

/*VARARGS1*/
int
exec(int type, ...)
{
    va_list         args;

    int         i;
    int         procuid;
    int         procgid;
    int         ret;
    int         fr_flg;

    char            *cp;
    char            *infile;
    char            *outfile;
    char            *errfile;
    char            *sep;

    char            **listp;
    char            **file_list;
    char            *printerName;
    char            *printerNameToShow;
    static char     nameBuf[100];
    char            *clean_title;

    PSTATUS         *printer;

    RSTATUS         *request;

    FSTATUS         *form;

    EXEC            *ep;

    PWSTATUS        *pwheel;
    time_t          now;
    struct passwd       *pwp;
#ifdef LP_USE_PAPI_ATTR
    struct stat     tmpBuf;
    char            tmpName[BUFSIZ];
    char            *path = NULL;
#endif
    char *av[ARG_MAX];
    char **envp = NULL;
    int ac = 0;
    char    *mail_zonename = NULL;
    char    *slabel = NULL;
    int setid = 1;
    char    *ridno = NULL, *tmprid = NULL;

    syslog(LOG_DEBUG, "exec(%s)", _exec_name(type));

    memset(av, 0, sizeof (*av));

    va_start (args, type);

    switch (type) {

    case EX_INTERF:
        printer = va_arg(args, PSTATUS *);
        request = printer->request;
        ep = printer->exec;
        break;

    case EX_FAULT_MESSAGE:
        printer = va_arg(args, PSTATUS *);
        request = va_arg(args, RSTATUS *);
        if (! ( printer->status & (PS_FORM_FAULT | PS_SHOW_FAULT))) {
            return(0);
        }
        ep = printer->fault_exec;
        printerName = (printer->printer && printer->printer->name
                  ? printer->printer->name : "??");
            snprintf(nameBuf, sizeof (nameBuf),
                "%s (on %s)\n", printerName, Local_System);

        printerNameToShow = nameBuf;

        (void) time(&now);
        (void) strftime(time_buf, sizeof (time_buf),
            NULL, localtime(&now));
        break;

    case EX_SLOWF:
        request = va_arg(args, RSTATUS *);
        ep = request->exec;
        break;

    case EX_NOTIFY:
        request = va_arg(args, RSTATUS *);
        if (request->request->actions & ACT_NOTIFY) {
            errno = EINVAL;
            return (-1);
        }
        ep = request->exec;
        break;

    case EX_ALERT:
        printer = va_arg(args, PSTATUS *);
        if (!(printer->printer->fault_alert.shcmd)) {
            errno = EINVAL;
            return(-1);
        }
        ep = printer->alert->exec;
        break;

    case EX_PALERT:
        pwheel = va_arg(args, PWSTATUS *);
        ep = pwheel->alert->exec;
        break;

    case EX_FORM_MESSAGE:
        (void) time(&now);
        (void) strftime(time_buf, sizeof (time_buf),
            NULL, localtime(&now));

        /*FALLTHRU*/
    case EX_FALERT:
        form = va_arg(args, FSTATUS *);
        ep = form->alert->exec;
        break;

    default:
        errno = EINVAL;
        return(-1);

    }
    va_end (args);

    if (!ep || (ep->pid > 0)) {
        errno = EBUSY;
        return(-1);
    }

    ep->flags = 0;

    key = ep->key = getkey();

    switch ((ep->pid = Fork1(ep))) {

    case -1:
        relock ();
        return(-1);

    case 0:
        /*
         * We want to be able to tell our parent how we died.
         */
        lp_alloc_fail_handler = child_mallocfail;
        break;

    default:
        switch(type) {

        case EX_INTERF:
            request->request->outcome |= RS_PRINTING;
            break;

        case EX_NOTIFY:
            request->request->outcome |= RS_NOTIFYING;
            break;

        case EX_SLOWF:
            request->request->outcome |= RS_FILTERING;
            request->request->outcome &= ~RS_REFILTER;
            break;

        }
        return(0);

    }

    for (i = 0; i < NSIG; i++)
        (void)signal (i, SIG_DFL);
    (void)signal (SIGALRM, SIG_IGN);
    (void)signal (SIGTERM, sigtrap);

    closelog();
    for (i = 0; i < OpenMax; i++)
        if (i != ChildMd->writefd)
            Close (i);
    openlog("lpsched", LOG_PID|LOG_NDELAY|LOG_NOWAIT, LOG_LPR);

    setpgrp();

    /* Set a default path */
    addenv (&envp, "PATH", "/usr/lib/lp/bin:/usr/bin:/bin:/usr/sbin:/sbin");
    /* copy locale related variables */
    addenv (&envp, "TZ", getenv("TZ"));
    addenv (&envp, "LANG", getenv("LANG"));
    addenv (&envp, "LC_ALL", getenv("LC_ALL"));
    addenv (&envp, "LC_COLLATE", getenv("LC_COLLATE"));
    addenv (&envp, "LC_CTYPE", getenv("LC_CTYPE"));
    addenv (&envp, "LC_MESSAGES", getenv("LC_MESSAGES"));
    addenv (&envp, "LC_MONETARY", getenv("LC_MONETARY"));
    addenv (&envp, "LC_NUMERIC", getenv("LC_NUMERIC"));
    addenv (&envp, "LC_TIME", getenv("LC_TIME"));

    sprintf ((cp = BIGGEST_NUMBER_S), "%ld", key);
    addenv (&envp, "SPOOLER_KEY", cp);

#if defined(DEBUG)
    addenv (&envp, "LPDEBUG", (debug? "1" : "0"));
#endif

    /*
     * Open the standard input, standard output, and standard error.
     */
    switch (type) {

    case EX_SLOWF:
    case EX_INTERF:
        /*
         * stdin:  /dev/null
         * stdout: /dev/null (EX_SLOWF), printer port (EX_INTERF)
         * stderr: req#
         */
        infile = 0;
        outfile = 0;
        errfile = makereqerr(request);
        break;

    case EX_NOTIFY:
        /*
         * stdin:  req#
         * stdout: /dev/null
         * stderr: /dev/null
         */
        infile = makereqerr(request);
        outfile = 0;
        errfile = 0;

        break;

    case EX_ALERT:
    case EX_FALERT:
    case EX_PALERT:
    case EX_FAULT_MESSAGE:
    case EX_FORM_MESSAGE:
        /*
         * stdin:  /dev/null
         * stdout: /dev/null
         * stderr: /dev/null
         */
        infile = 0;
        outfile = 0;
        errfile = 0;
        break;

    }

    if (infile) {
        if (Open(infile, O_RDONLY) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    } else {
        if (Open("/dev/null", O_RDONLY) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    }

    if (outfile) {
        if (Open(outfile, O_CREAT|O_TRUNC|O_WRONLY, 0600) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    } else {
        /*
         * If EX_INTERF, this is still needed to cause the
         * standard error channel to be #2.
         */
        if (Open("/dev/null", O_WRONLY) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    }

    if (errfile) {
        if (Open(errfile, O_CREAT|O_TRUNC|O_WRONLY, 0600) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    } else {
        if (Open("/dev/null", O_WRONLY) == -1)
            Done (EXEC_EXIT_NOPEN, errno);
    }

    switch (type) {

    case EX_INTERF:
        /*
         * Opening a ``port'' can be dangerous to our health:
         *
         *  - Hangups can occur if the line is dropped.
         *  - The printer may send an interrupt.
         *  - A FIFO may be closed, generating SIGPIPE.
         *
         * We catch these so we can complain nicely.
         */
        trap_fault_signals ();

        (void)Close (1);

        procuid = request->secure->uid;
        procgid = request->secure->gid;

        if (printer->printer->dial_info)
        {
            ret = open_dialup(request->printer_type,
                printer->printer);
            if (ret == 0)
                do_undial = 1;
        }
        else
        {
            ret = open_direct(request->printer_type,
                printer->printer);
            do_undial = 0;
            /* this is a URI */
            if (is_printer_uri(printer->printer->device) == 0)
                addenv(&envp, "DEVICE_URI",
                     printer->printer->device);
        }
                addenv(&envp, "DEVICE_URI",
                     printer->printer->device);
        if (ret != 0)
            Done (ret, errno);

        if (!(request->request->outcome & RS_FILTERED))
            file_list = request->request->file_list;

        else {
            register int        count   = 0;
            register char *     num = BIGGEST_REQID_S;
            register char *     prefix;

            prefix = makestr(
                Lp_Temp,
                "/F",
                getreqno(request->secure->req_id),
                "-",
                (char *)0
            );

            file_list = (char **)Malloc(
                (lenlist(request->request->file_list) + 1)
                  * sizeof(char *)
            );

            for (
                listp = request->request->file_list;
                *listp;
                listp++
            ) {
                sprintf (num, "%d", count + 1);
                file_list[count] = makestr(
                    prefix,
                    num,
                    (char *)0
                );
                count++;
            }
            file_list[count] = 0;
        }

#ifdef LP_USE_PAPI_ATTR
        /*
         * Check if the PAPI job attribute file exists, if it does
         * pass the file's pathname to the printer interface script
         * in an environment variable. This file is created when
         * print jobs are submitted via the PAPI interface.
         */
        snprintf(tmpName, sizeof (tmpName), "%s-%s",
            getreqno(request->secure->req_id), LP_PAPIATTRNAME);
        path = makepath(Lp_Temp, tmpName, (char *)0);
        if ((path != NULL) && (stat(path, &tmpBuf) == 0))
        {
            /*
             * IPP job attribute file exists for this job so
             * set the environment variable
             */
            addenv(&envp, "ATTRPATH", path);
        }
        Free(path);

        /*
         * now set environment variable for the printer's PostScript
         * Printer Description (PPD) file, this is used by the filter
         * when forming the print data for this printer.
         */
        if ((request->printer != NULL) &&
            (request->printer->printer != NULL) &&
            (request->printer->printer->name != NULL))
        {
            snprintf(tmpName, sizeof (tmpName), "%s.ppd",
                request->printer->printer->name);
            path = makepath(ETCDIR, "ppd", tmpName, (char *)0);
            if ((path != NULL) && (stat(path, &tmpBuf) == 0))
            {
                addenv(&envp, "PPD", path);
            }
            Free(path);
        }
#endif

        if (request->printer_type)
            addenv(&envp, "TERM", request->printer_type);

        if (!(printer->printer->daisy)) {
            register char * chset = 0;
            register char * csp;

            if (
                request->form
                 && request->form->form->chset
                 && request->form->form->mandatory
                 && !STREQU(NAME_ANY, request->form->form->chset)
            )
                chset = request->form->form->chset;

            else if (
                request->request->charset
                 && !STREQU(NAME_ANY, request->request->charset)
            )
                chset = request->request->charset;

            if (chset) {
                csp = search_cslist(
                    chset,
                    printer->printer->char_sets
                );

                /*
                 * The "strtok()" below wrecks the string
                 * for future use, but this is a child
                 * process where it won't be needed again.
                 */
                addenv (&envp, "CHARSET",
                    (csp? strtok(csp, "=") : chset)
                );
            }
        }

        if (request->fast)
            addenv(&envp, "FILTER", request->fast);

        /*
         * Add the sensitivity label to the environment for
         * banner page and header/footer processing
         */

        if (is_system_labeled() && request->secure->slabel != NULL)
            addenv(&envp, "SLABEL", request->secure->slabel);

        /*
         * Add the system name to the user name (ala system!user)
         * unless it is already there. RFS users may have trouble
         * here, sorry!
         */
        cp = strchr(request->secure->user, '@');

        allTraysWithForm(printer, request->form);

        /*
         * Fix for 4137389
         * Remove double quotes from title string.
         */
        fr_flg = 1;
        clean_title = strdup(NB(request->request->title));
        if (clean_title == NULL) {
            /*
             * strdup failed. We're probably hosed
             * but try setting clean_title
             * to original title and continuing.
             */
            clean_title = NB(request->request->title);
            fr_flg = 0;
        } else if (strcmp(clean_title, "") != 0) {
            char *ct_p;

            for (ct_p = clean_title; *ct_p != NULL; ct_p++) {
                if (*ct_p == '"')
                    *ct_p = ' ';
            }
        }

        av[ac++] = arg_string(TRUSTED, "%s/%s", Lp_A_Interfaces,
                    printer->printer->name);
        /*
         * Read the options field of the request
         * In case of remote lpd request
         * the options field will have
         * job-id-requested. This is the
         * id sent by the client
         */
        if (request->request->options != NULL) {
            char *options = NULL, *temp = NULL;
            options = temp = strdup(request->request->options);

            /*
             * Search for job-id-requested in
             * options string
             */
            options = strstr(options, "job-id-requested");
            if (options != NULL) {
                /*
                 * Extract the ridno from the string
                 * job-id-requested=xxx
                 * In this case ridno = xxx
                 */
                if (STRNEQU(options, "job-id-requested=", 17)) {
                    ridno = strdup(options + 17);
                    tmprid = strstr(ridno, " ");
                    if (ridno != NULL) {
                        /*
                         * Read job-id-requested
                         * successfully
                         */
                        tmprid = strstr(ridno, " ");
                        if (tmprid != NULL)
                            *tmprid = '\0';

                        setid = 0;
                    } else
                        /*
                         * could not read
                         * ridno from the string
                         * job-id-requested=xxx
                         */
                        setid = 1;
                } else
                    /*
                     * could not read
                     * ridno from the string
                     * job-id-requested=xxx
                     */
                    setid = 1;
            } else
                /*
                 * No job-id-requested in
                 * request options
                 */
                setid = 1;

            if (temp != NULL)
                free(temp);

        } else
            /*
             * options field in request structure
             * not set
             */
            setid = 1;


        /*
         * setid = 1 means the job-id-requested attribute
         * is not set so read the request->secure->req_id
         */
        if (setid)
            av[ac++] = arg_string(TRUSTED, "%s",
                request->secure->req_id);
        else {
            /*
             * From request->secure->req_id extract the
             * printer-name.
             * request->secure->req_id = <printer-name>-<req_id>
             * The final req-id will be
             * <printer-name>-<ridno>
             */
            char *r1 = NULL, *r2 = NULL, *tmp = NULL;
            r1 = r2 = tmp = strdup(request->secure->req_id);
            r2 = strrchr(r1, '-');
            if (r2 != NULL) {
                char *r3 = NULL;
                int lr1 = strlen(r1);
                int lr2 = strlen(r2);
                r1[lr1 - lr2 + 1] = '\0';

                /*
                 * Now r1 = <printer-name>-
                 */
                lr1 = strlen(r1);
                lr2 = strlen(ridno);

                r3 = (char *)malloc(lr1+lr2+1);
                if (r3 != NULL) {
                    strcpy(r3, r1);
                    strcat(r3, ridno);
                    /*
                     * Here r3 = <printer-name>-<ridno>
                     */
                    av[ac++] = arg_string(TRUSTED,
                        "%s", r3);
                    free(r3);
                } else
                    av[ac++] = arg_string(TRUSTED, "%s",
                        request->secure->req_id);

            } else
                av[ac++] = arg_string(TRUSTED, "%s",
                    request->secure->req_id);

            if (tmp != NULL)
                free(tmp);

            if (ridno != NULL)
                free(ridno);
        }

        av[ac++] = arg_string(UNTRUSTED, "%s", request->request->user);
        av[ac++] = arg_string(TRUSTED, "%s", clean_title);
        av[ac++] = arg_string(TRUSTED, "%d", request->copies);

        if (fr_flg)
            free (clean_title);

        sep = "";

        /*
         * Do the administrator defined key=value pair options
         */

        argbuf[0] = '\0';

        if (printer->printer->options) {
            char **tmp = printer->printer->options;
            while(*tmp != NULL) {
                STRLCAT(argbuf, sep, sizeof (argbuf));
                sep = " ";
                STRLCAT(argbuf, *tmp++, sizeof (argbuf));
            }
        }

        /*
         * Do the administrator defined ``stty'' stuff before
         * the user's -o options, to allow the user to override.
         */
        if (printer->printer->stty) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "stty='", sizeof (argbuf));
            STRLCAT (argbuf, printer->printer->stty,
                sizeof (argbuf));
            STRLCAT (argbuf, "'", sizeof (argbuf));
        }

        /*
         * Do all of the user's options except the cpi/lpi/etc.
         * stuff, which is done separately.
         */
        if (request->request->options) {
            listp = dashos(request->request->options);
            while (*listp) {
                if (
                    !STRNEQU(*listp, "cpi=", 4)
                     && !STRNEQU(*listp, "lpi=", 4)
                     && !STRNEQU(*listp, "width=", 6)
                     && !STRNEQU(*listp, "length=", 7)
                ) {
                    STRLCAT (argbuf, sep, sizeof (argbuf));
                    sep = " ";
                    STRLCAT (argbuf, *listp,
                        sizeof (argbuf));
                }
                listp++;
            }
        }

        /*
         * The "pickfilter()" routine (from "validate()")
         * stored the cpi/lpi/etc. stuff that should be
         * used for this request. It chose form over user,
         * and user over printer.
         */
        if (request->cpi) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "cpi=", sizeof (argbuf));
            STRLCAT (argbuf, request->cpi, sizeof (argbuf));
        }
        if (request->lpi) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "lpi=", sizeof (argbuf));
            STRLCAT (argbuf, request->lpi, sizeof (argbuf));
        }
        if (request->pwid) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "width=", sizeof (argbuf));
            STRLCAT (argbuf, request->pwid, sizeof (argbuf));
        }
        if (request->plen) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "length=", sizeof (argbuf));
            STRLCAT (argbuf, request->plen, sizeof (argbuf));
        }

        /*
         * Do the ``raw'' bit last, to ensure it gets
         * done. If the user doesn't want this, then he or
         * she can do the correct thing using -o stty=
         * and leaving out the -r option.
         */
        if (request->request->actions & ACT_RAW) {
            STRLCAT (argbuf, sep, sizeof (argbuf));
            sep = " ";
            STRLCAT (argbuf, "stty=-opost", sizeof (argbuf));
        }


        /* the "options" */
        av[ac++] = arg_string(UNTRUSTED, "%s", argbuf);

        for (listp = file_list; *listp; listp++)
            av[ac++] = arg_string(TRUSTED, "%s", *listp);

        (void)chfiles (file_list, procuid, procgid);

        break;


    case EX_SLOWF:
        if (request->slow)
            addenv(&envp, "FILTER", request->slow);

        procuid = request->secure->uid;
        procgid = request->secure->gid;

        cp = _alloc_files(
            lenlist(request->request->file_list),
            getreqno(request->secure->req_id),
            procuid, procgid);

        av[ac++] = arg_string(TRUSTED, "%s", Lp_Slow_Filter);
        av[ac++] = arg_string(TRUSTED, "%s/%s", Lp_Temp, cp);
        for (listp = request->request->file_list; *listp; listp++)
            av[ac++] = arg_string(TRUSTED, "%s", *listp);

        (void)chfiles (request->request->file_list, procuid, procgid);

#ifdef LP_USE_PAPI_ATTR
        /*
         * Check if the PAPI job attribute file exists, if it does
         * pass the file's pathname to the slow-filters in an
         * environment variable. Note: this file is created when
         * print jobs are submitted via the PAPI interface.
         */
        snprintf(tmpName, sizeof (tmpName), "%s-%s",
            getreqno(request->secure->req_id), LP_PAPIATTRNAME);
        path = makepath(Lp_Temp, tmpName, (char *)0);
        if ((path != NULL) && (stat(path, &tmpBuf) == 0))
        {
            /*
             * IPP job attribute file exists for this job so
             * set the environment variable
             */
            addenv(&envp, "ATTRPATH", path);
        }
        Free(path);


        /*
         * now set environment variable for the printer's PostScript
         * Printer Description (PPD) file, this is used by the filter
         * when forming the print data for this printer.
         */
        if ((request->printer != NULL) &&
            (request->printer->printer != NULL) &&
            (request->printer->printer->name != NULL))
        {
            snprintf(tmpName, sizeof (tmpName), "%s.ppd",
                request->printer->printer->name);
            path = makepath(ETCDIR, "ppd", tmpName, (char *)0);
            if ((path != NULL) && (stat(path, &tmpBuf) == 0))
            {
                addenv(&envp, "PPD", path);
            }
            Free(path);
        }
#endif
        break;

    case EX_ALERT:
        procuid = Lp_Uid;
        procgid = Lp_Gid;
        (void)Chown (printer->alert->msgfile, procuid, procgid);

        av[ac++] = arg_string(TRUSTED, "%s/%s/%s", Lp_A_Printers,
                printer->printer->name, ALERTSHFILE);
        av[ac++] = arg_string(TRUSTED, "%s", printer->alert->msgfile);

        break;

    case EX_PALERT:
        procuid = Lp_Uid;
        procgid = Lp_Gid;
        (void)Chown (pwheel->alert->msgfile, procuid, procgid);

        av[ac++] = arg_string(TRUSTED, "%s/%s/%s", Lp_A_PrintWheels,
                pwheel->pwheel->name, ALERTSHFILE);
        av[ac++] = arg_string(TRUSTED, "%s", printer->alert->msgfile);

        break;

    case EX_FALERT:
        procuid = Lp_Uid;
        procgid = Lp_Gid;
        (void)Chown (form->alert->msgfile, procuid, procgid);

        av[ac++] = arg_string(TRUSTED, "%s/%s/%s", Lp_A_Forms,
                form->form->name, ALERTSHFILE);
        av[ac++] = arg_string(TRUSTED, "%s", printer->alert->msgfile);

        break;

    case EX_FORM_MESSAGE:
        procuid = Lp_Uid;
        procgid = Lp_Gid;

        av[ac++] = arg_string(TRUSTED, "%s/form", Lp_A_Faults);
        av[ac++] = arg_string(TRUSTED, "%s", form->form->name);
        av[ac++] = arg_string(TRUSTED, "%s", time_buf);
        av[ac++] = arg_string(TRUSTED, "%s/%s/%s", Lp_A_Forms,
                form->form->name, FORMMESSAGEFILE);

        break;

    case EX_FAULT_MESSAGE:
        procuid = Lp_Uid;
        procgid = Lp_Gid;

        av[ac++] = arg_string(TRUSTED, "%s/printer", Lp_A_Faults);
        av[ac++] = arg_string(TRUSTED, "%s", printerNameToShow);
        av[ac++] = arg_string(TRUSTED, "%s", time_buf);
        av[ac++] = arg_string(TRUSTED, "%s/%s/%s", Lp_A_Printers,
                printerName, FAULTMESSAGEFILE);

        break;

    case EX_NOTIFY:
        if (request->request->alert) {
            procuid = request->secure->uid;
            procgid = request->secure->gid;

            av[ac++] = arg_string(TRUSTED, "%s",
                    request->request->alert);
        } else {
            char *user = strdup(request->request->user);
            clean_string(user);
            slabel = request->secure->slabel;

            if (request->request->actions & ACT_WRITE) {
                av[ac++] = arg_string(TRUSTED, "%s", BINWRITE);
                snprintf(argbuf, sizeof (argbuf),
                    "%s %s || %s %s",
                    BINWRITE, user,
                    BINMAIL, user
                );
                av[ac++] = arg_string(TRUSTED, "/bin/sh");
                av[ac++] = arg_string(TRUSTED, "-c");
                av[ac++] = arg_string(TRUSTED, "%s", argbuf);
            } else if ((getzoneid() == GLOBAL_ZONEID) &&
                   is_system_labeled() && (slabel != NULL)) {
                /*
                 * If in the global zone and the system is
                 * labeled, mail is handled via a local
                 * labeled zone that is the same label as
                 * the request.
                 */
                if ((mail_zonename =
                    get_labeled_zonename(slabel)) ==
                    (char *)-1) {
                    /*
                     * Cannot find labeled zone, just
                     * return 0.
                     */
                    return(0);
                }
            }
            if (mail_zonename == NULL) {
                procuid = Lp_Uid;
                procgid = Lp_Gid;
                av[ac++] = arg_string(TRUSTED, "%s", BINMAIL);
                av[ac++] = arg_string(UNTRUSTED, "%s", user);
            } else {
                procuid = getuid();
                procgid = getgid();
                av[ac++] = arg_string(TRUSTED, "%s",
                    "/usr/sbin/zlogin");
                av[ac++] = arg_string(TRUSTED, "%s",
                    mail_zonename);
                av[ac++] = arg_string(TRUSTED, "%s",
                    BINMAIL);
                av[ac++] = arg_string(UNTRUSTED, "%s",
                    user);
                Free(mail_zonename);
            }

            free(user);
        }
        break;
    }

    av[ac++] = NULL;

    Fork2 ();
    /* only the child returns */

    /*
     * Correctly set up the supplemental group list
     * for proper file access (before execl the interface program)
     */

    pwp = getpwuid(procuid);
    if (pwp == NULL) {
        note("getpwuid(%d) call failed\n", procuid);
    } else if (initgroups(pwp->pw_name, procgid) < 0) {
        note("initgroups() call failed %d\n", errno);
    }

    setgid (procgid);
    setuid (procuid);

    /*
     * The shell doesn't allow the "trap" builtin to set a trap
     * for a signal ignored when the shell is started. Thus, don't
     * turn off signals in the last child!
     */

#ifdef DEBUG
    for (i = 0; av[i] != NULL; i++)
        note("exec(%s): av[%d] = %s", _exec_name(type), i, av[i]);
    for (i = 0; envp[i] != NULL; i++)
        note("exec(%s): envp[%d] = %s", _exec_name(type), i, envp[i]);
#endif

    execvpe(av[0], av, envp);
    Done (EXEC_EXIT_NEXEC, errno);
    /*NOTREACHED*/
    return (0);
}

/**
 ** addenv() - ADD A VARIABLE TO THE ENVIRONMENT
 **/

static void
addenv(char ***envp, char *name, char *value)
{
    register char *     cp;

    if ((name == NULL) || (value == NULL))
        return;

    if ((cp = makestr(name, "=", value, (char *)0)))
        addlist(envp, cp);
    return;
}

/**
 ** Fork1() - FORK FIRST CHILD, SET UP CONNECTION TO IT
 **/

static int
Fork1(EXEC *ep)
{
    int         pid;
    int         fds[2];

    if (pipe(fds) == -1) {
        note("Failed to create pipe for child process (%s).\n", PERROR);
        errno = EAGAIN ;
        return(-1);
    }

    ep->md = mconnect((char *)0, fds[0], fds[1]);

    switch (pid = fork()) {

    case -1:
        mdisconnect(ep->md);
        close(fds[0]);
        close(fds[1]);
        ep->md = 0;
        return (-1);

    case 0:
        ChildMd = mconnect(NULL, fds[1], fds[1]);
        return (0);

    default:
        mlistenadd(ep->md, POLLIN);
        return (pid);
    }
}

/**
 ** Fork2() - FORK SECOND CHILD AND WAIT FOR IT
 **/

static void
Fork2(void)
{
    switch ((ChildPid = fork())) {

    case -1:
        Done (EXEC_EXIT_NFORK, errno);
        /*NOTREACHED*/

    case 0:
        return;

    default:
        /*
         * Delay calling "ignore_fault_signals()" as long
         * as possible, to give the child a chance to exec
         * the interface program and turn on traps.
         */

        cool_heels ();
        /*NOTREACHED*/

    }
}


/**
 ** cool_heels() - WAIT FOR CHILD TO "DIE"
 **/

static void
cool_heels(void)
{
    int         status;

    /*
     * At this point our only job is to wait for the child process.
     * If we hang out for a bit longer, that's okay.
     * By delaying before turning off the fault signals,
     * we increase the chance that the child process has completed
     * its exec and has turned on the fault traps. Nonetheless,
     * we can't guarantee a zero chance of missing a fault.
     * (We don't want to keep trapping the signals because the
     * interface program is likely to have a better way to handle
     * them; this process provides only rudimentary handling.)
     *
     * Note that on a very busy system, or with a very fast interface
     * program, the tables could be turned: Our sleep below (coupled
     * with a delay in the kernel scheduling us) may cause us to
     * detect the fault instead of the interface program.
     *
     * What we need is a way to synchronize with the child process.
     */
    sleep (1);
    ignore_fault_signals ();

    WaitedChildPid = 0;
    while ((WaitedChildPid = wait(&status)) != ChildPid)
        ;

    if (
        EXITED(status) > EXEC_EXIT_USER
         && EXITED(status) != EXEC_EXIT_FAULT
    )
        Done (EXEC_EXIT_EXIT, EXITED(status));

    done (status, 0);   /* Don't use Done() */
    /*NOTREACHED*/
}


/**
 ** trap_fault_signals() - TRAP SIGNALS THAT CAN OCCUR ON PRINTER FAULT
 ** ignore_fault_signals() - IGNORE SAME
 **/

static void
trap_fault_signals(void)
{
    signal (SIGHUP, sigtrap);
    signal (SIGINT, sigtrap);
    signal (SIGQUIT, sigtrap);
    signal (SIGPIPE, sigtrap);
    return;
}

static void
ignore_fault_signals(void)
{
    signal (SIGHUP, SIG_IGN);
    signal (SIGINT, SIG_IGN);
    signal (SIGQUIT, SIG_IGN);
    signal (SIGPIPE, SIG_IGN);
    return;
}

/**
 ** sigtrap() - TRAP VARIOUS SIGNALS
 **/

static void
sigtrap(int sig)
{
    signal (sig, SIG_IGN);
    switch (sig) {

    case SIGHUP:
        Done (EXEC_EXIT_HUP, 0);
        /*NOTREACHED*/

    case SIGQUIT:
    case SIGINT:
        Done (EXEC_EXIT_INTR, 0);
        /*NOTREACHED*/

    case SIGPIPE:
        Done (EXEC_EXIT_PIPE, 0);
        /*NOTREACHED*/

    case SIGTERM:
        /*
         * If we were killed with SIGTERM, it should have been
         * via the Spooler who should have killed the entire
         * process group. We have to wait for the children,
         * since we're their parent, but WE MAY HAVE WAITED
         * FOR THEM ALREADY (in cool_heels()).
         */
        if (ChildPid != WaitedChildPid) {
            register int        cpid;

            while (
                (cpid = wait((int *)0)) != ChildPid
                 && (cpid != -1 || errno != ECHILD)
            )
                ;
        }

        /*
         * We can't rely on getting SIGTERM back in the wait()
         * above, because, for instance, some shells trap SIGTERM
         * and exit instead. Thus we force it.
         */
        done (SIGTERM, 0);  /* Don't use Done() */
        /*NOTREACHED*/
    }
}

/**
 ** done() - TELL SPOOLER THIS CHILD IS DONE
 **/

static void
done(int status, int err)
{
    if (do_undial)
        undial (1);

    mputm (ChildMd, S_CHILD_DONE, key, status, err);
    mdisconnect (ChildMd);

    exit (0);
    /*NOTREACHED*/
}

/**
 ** child_mallocfail()
 **/

static void
child_mallocfail(void)
{
    Done (EXEC_EXIT_NOMEM, ENOMEM);
}