lib/papi/job.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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*LINTLIBRARY*/

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <libintl.h>
#include <pwd.h>
#include <sys/stat.h>
#include <papi_impl.h>

/*
 * for an older application that may have been linked with a pre-v1.0
 * PAPI implementation.
 */
papi_status_t
papiAttributeListAdd(papi_attribute_t ***attrs, int flags, char *name,
        papi_attribute_value_type_t type, papi_attribute_value_t *value)
{
    return (papiAttributeListAddValue(attrs, flags, name, type, value));
}

#ifdef LP_USE_PAPI_ATTR
static papi_status_t psm_modifyAttrsFile(papi_attribute_t **attrs, char *file);
static papi_status_t psm_modifyAttrsList(char *file, papi_attribute_t **attrs,
                    papi_attribute_t ***newAttrs);
#endif

int32_t
check_job_id(papi_service_t svc, char *printer, int32_t id)
{
    papi_job_t *jobs = NULL;
    papi_status_t status;
    int ret = -1;
    char *jattrs[] = { "job-id",
        "job-id-requested", NULL };

    status = papiPrinterListJobs(svc, printer, jattrs, PAPI_LIST_JOBS_ALL,
        0, &jobs);

    if (status != PAPI_OK) {
        detailed_error(svc,
            gettext("Failed to query service for %s: %s\n"),
            printer, lpsched_status_string(status));
        return (-1);
    }

    if (jobs != NULL) {
        int i = 0;

        for (i = 0; jobs[i] != NULL; i++) {
            int32_t rid = -1;
            int32_t jid = -1;
            papi_attribute_t **list =
                papiJobGetAttributeList(jobs[i]);

            papiAttributeListGetInteger(list, NULL,
                "job-id-requested", &rid);
            papiAttributeListGetInteger(list, NULL,
                "job-id", &jid);

            /*
             * check if id matches with either rid or jid
             */
            if (rid == id) {
                /* get the actual id and return it */
                papiAttributeListGetInteger(list, NULL,
                    "job-id", &id);
                return (id);
            } else if (jid == id) {
                if (rid != -1) {
                    /*
                     * It is a remote lpd job.
                     * It cannot be modified based on job-id
                     * or spool number
                     */
                    return (-1);
                } else {
                    /*
                     * It is either local job or
                     * remote ipp job
                     */
                    return (id);
                }
            }
        }
    }
    return (id);
}

void
papiJobFree(papi_job_t job)
{
    job_t *tmp = (job_t *)job;

    if (tmp != NULL) {
        papiAttributeListFree(tmp->attributes);
        free(tmp);
    }
}

void
papiJobListFree(papi_job_t *jobs)
{
    if (jobs != NULL) {
        int i;

        for (i = 0; jobs[i] != NULL; i++) {
            papiJobFree(jobs[i]);
        }
        free(jobs);
    }
}

papi_attribute_t **
papiJobGetAttributeList(papi_job_t job)
{
    job_t *tmp = (job_t *)job;

    if (tmp != NULL)
        return (tmp->attributes);

    return (NULL);
}

char *
papiJobGetPrinterName(papi_job_t job)
{
    job_t *tmp = (job_t *)job;
    char *result = NULL;

    if (tmp != NULL)
        papiAttributeListGetString(tmp->attributes, NULL,
            "printer-name", &result);

    return (result);
}

int32_t
papiJobGetId(papi_job_t job)
{
    job_t *tmp = (job_t *)job;
    int result = -1;

    if (tmp != NULL)
        papiAttributeListGetInteger(tmp->attributes, NULL, "job-id",
            &result);

    return (result);
}

static REQUEST *
create_request(papi_service_t svc, char *printer, papi_attribute_t **attributes)
{
    REQUEST *r;

    if ((r = calloc(1, sizeof (*r))) != NULL) {
        char *hostname = NULL;

        r->priority = -1;
        r->destination = printer_name_from_uri_id(printer, -1);

        papiAttributeListGetString(attributes, NULL,
            "job-originating-host-name", &hostname);

        if (hostname == NULL) {
            char host[BUFSIZ];

            if (gethostname(host, sizeof (host)) == 0)
                papiAttributeListAddString(&attributes,
                    PAPI_ATTR_REPLACE,
                    "job-originating-host-name",
                    host);
        }

        job_attributes_to_lpsched_request(svc, r, attributes);
    }

    return (r);
}

static papi_status_t
authorized(service_t *svc, int32_t id)
{
    papi_status_t result = PAPI_NOT_AUTHORIZED; /* assume the worst */
    char file[32];
    REQUEST *r;

    snprintf(file, sizeof (file), "%d-0", id);
    if ((r = getrequest(file)) != NULL) {
        uid_t uid = getuid();
        struct passwd *pw = NULL;
        char *user = "intruder";    /* assume an intruder */

        if ((pw = getpwuid(uid)) != NULL)
            user = pw->pw_name; /* use the process owner */

        if ((uid == 0) || (uid == 71)) { /* root/lp can forge this */
            papi_status_t s;
            s = papiAttributeListGetString(svc->attributes, NULL,
                "user-name", &user);
            if (s != PAPI_OK)   /* true root/lp are almighty */
                result = PAPI_OK;
        }

        if (result != PAPI_OK) {
            if (strcmp(user, r->user) == 0)
                result = PAPI_OK;
            else {
                /*
                 * user and r->user might contain the
                 * host info also
                 */
                char *token1 = strtok(r->user, "@");
                char *token2 = strtok(NULL, "@");
                char *token3 = strtok(user, "@");
                char *token4 = strtok(NULL, "@");

                /*
                 * token1 and token3 contain usernames
                 * token2 and token4 contain hostnames
                 */
                if ((token1 == NULL) || (token3 == NULL))
                    result = PAPI_NOT_AUTHORIZED;
                else if ((token4 != NULL) &&
                    (strcmp(token4, "localhost") == 0) &&
                    (strcmp(token3, "root") == 0) ||
                    (strcmp(token3, "lp") == 0)) {
                    /*
                     * root/lp user on server can
                     * cancel any requset
                     */
                    result = PAPI_OK;
                } else if (strcmp(token1, token3) == 0) {
                    /*
                     * usernames are same
                     * compare the hostnames
                     */
                    if ((token4 != NULL) &&
                        (token2 != NULL) &&
                        (strcmp(token4, "localhost") ==
                        0)) {
                        /*
                         * Its server machine
                         */
                        static char host[256];
                        if (gethostname(host,
                            sizeof (host)) == 0) {
                            if ((host != NULL) &&
                                (strcmp(host,
                                token2) == 0))
                                result =
                                    PAPI_OK;
                        }

                    } else if ((token4 != NULL) &&
                        (token2 != NULL) &&
                        (strcmp(token4, token2) == 0)) {
                        result = PAPI_OK;
                    } else if ((token4 == NULL) &&
                        (token2 != NULL)) {
                        /*
                         * When the request is sent from
                         * client to server using ipp
                         * token4 is NULL
                         */
                        result = PAPI_OK;
                    }
                }
            }
        }

        freerequest(r);
    } else
        result = PAPI_NOT_FOUND;

    return (result);
}

static papi_status_t
copy_file(char *from, char *to)
{
    int ifd, ofd;
    char buf[BUFSIZ];
    int rc;

    if ((ifd = open(from, O_RDONLY)) < 0)
        return (PAPI_DOCUMENT_ACCESS_ERROR);

    if ((ofd = open(to, O_WRONLY)) < 0) {
        close(ifd);
        return (PAPI_NOT_POSSIBLE);
    }

    while ((rc = read(ifd, buf, sizeof (buf))) > 0)
        write(ofd, buf, rc);

    close(ifd);
    close(ofd);

    return (PAPI_OK);
}


#ifdef LP_USE_PAPI_ATTR
/*
 * *****************************************************************************
 *
 * Description: Create a file containing all the attributes in the attribute
 *              list passed to this function.
 *              This file is then passed through lpsched and given to either
 *              a slow-filter or to the printer's interface script to process
 *              the attributes.
 *
 * Parameters:  attrs - list of attributes and their values
 *              file  - file pathname to create and put the attributes into.
 *
 * *****************************************************************************
 */

static papi_status_t
psm_copy_attrsToFile(papi_attribute_t **attrs, char *file)

{
    papi_status_t result = PAPI_OK;

    if ((attrs != NULL) && (*attrs != NULL)) {
        FILE *out = NULL;

        if ((out = fopen(file, "w")) != NULL) {
            papiAttributeListPrint(out, attrs, "");
            fclose(out);
        } else {
            result = PAPI_NOT_POSSIBLE;
        }
    }

    return (result);
} /* psm_copy_attrsToFile */


/*
 * *****************************************************************************
 *
 * Description: Modify the given attribute 'file' with the attributes from the
 *              'attrs' list. Attributes already in the file will be replaced
 *              with the new value. New attributes will be added into the file.
 *
 * Parameters:  attrs - list of attributes and their values
 *              file  - file pathname to create and put the attributes into.
 *
 * *****************************************************************************
 */

static papi_status_t
psm_modifyAttrsFile(papi_attribute_t **attrs, char *file)

{
    papi_status_t result = PAPI_OK;
    papi_attribute_t **newAttrs = NULL;
    struct stat   tmpBuf;
    FILE *fd = NULL;

    if ((attrs != NULL) && (*attrs != NULL) && (file != NULL)) {

        /*
         * check file exist before try to modify it, if it doesn't
         * exist assume there is an error
         */
        if (stat(file, &tmpBuf) == 0) {
            /*
             * if file is currently empty just write the given
             * attributes to the file otherwise exact the attributes
             * from the file and modify them accordingly before
             * writing them back to the file
             */
            if (tmpBuf.st_size == 0) {
                newAttrs = (papi_attribute_t **)attrs;

                fd = fopen(file, "w");
                if (fd != NULL) {
                    papiAttributeListPrint(fd,
                            newAttrs, "");
                    fclose(fd);
                } else {
                    result = PAPI_NOT_POSSIBLE;
                }
            } else {
                result =
                    psm_modifyAttrsList(file, attrs, &newAttrs);

                fd = fopen(file, "w");
                if (fd != NULL) {
                    papiAttributeListPrint(fd,
                                newAttrs, "");
                    fclose(fd);
                } else {
                    result = PAPI_NOT_POSSIBLE;
                }

                papiAttributeListFree(newAttrs);
            }
        } else {
            result = PAPI_NOT_POSSIBLE;
        }
    }

    return (result);
} /* psm_modifyAttrsFile */


/*
 * *****************************************************************************
 *
 * Description: Extracts the attributes in the given attribute 'file' and
 *              creates a new list 'newAttrs' containing the modified list of
 *              attributes.
 *
 * Parameters:  file  - pathname of file containing attributes to be modified
 *              attrs - list of attributes and their values to modify
 *              newAttrs - returns the modified list of attributes
 *
 * *****************************************************************************
 */

static papi_status_t
psm_modifyAttrsList(char *file, papi_attribute_t **attrs,
    papi_attribute_t ***newAttrs)

{
    papi_status_t result = PAPI_OK;
    papi_attribute_t  *nextAttr = NULL;
    papi_attribute_value_t  **values = NULL;
    void *iter = NULL;
    FILE *fd = NULL;
    register int fD = 0;
    char aBuff[200];
    char *a = NULL;
    char *p = NULL;
    int count = 0;
    int n = 0;

    fd = fopen(file, "r");
    if (fd != NULL) {
        fD = fileno(fd);
        a = &aBuff[0];
        p = &aBuff[0];
        count = read(fD, &aBuff[0], sizeof (aBuff) - 1);
        while ((result == PAPI_OK) && (count > 0)) {
            aBuff[count+n] = '\0';
            if (count == sizeof (aBuff) - n - 1) {
                p = strrchr(aBuff, '\n');
                if (p != NULL) {
                    /* terminate at last complete line */
                    *p = '\0';
                }
            }
            result = papiAttributeListFromString(
                newAttrs, PAPI_ATTR_EXCL, aBuff);

            if (result == PAPI_OK) {
                /*
                 * handle any part lines and then read the next
                 * buffer from the file
                 */
                n = 0;
                if (p != a) {
                    p++; /* skip NL */
                    n = sizeof (aBuff) - 1 - (p - a);
                    strncpy(aBuff, p, n);
                }
                count = read(fD, &aBuff[n],
                    sizeof (aBuff) - n - 1);
                p = &aBuff[0];
            }
        }
        fclose(fd);
    }

    /* now modify the attribute list with the new attributes in 'attrs' */

    nextAttr = papiAttributeListGetNext((papi_attribute_t **)attrs, &iter);
    while ((result == PAPI_OK) && (nextAttr != NULL)) {
        values = nextAttr->values;

        if ((values != NULL) && (*values != NULL)) {
            result = papiAttributeListAddValue(newAttrs,
                            PAPI_ATTR_REPLACE,
                            nextAttr->name,
                            nextAttr->type, *values);
            values++;
        }

        while ((result == PAPI_OK) &&
            (values != NULL) && (*values != NULL)) {
            result = papiAttributeListAddValue(newAttrs,
                            PAPI_ATTR_APPEND,
                            nextAttr->name,
                            nextAttr->type, *values);
            values++;
        }
        nextAttr =
            papiAttributeListGetNext((papi_attribute_t **)attrs, &iter);
    }

    return (result);
} /* papi_modifyAttrsList() */
#endif


papi_status_t
papiJobSubmit(papi_service_t handle, char *printer,
        papi_attribute_t **job_attributes,
        papi_job_ticket_t *job_ticket,
        char **files, papi_job_t *job)
{
    papi_status_t status;
    service_t *svc = handle;
    struct stat statbuf;
    job_t *j;
    int file_no;
    char *request_id = NULL;
    REQUEST *request;
    int i;
    char *c;
    char *tmp = NULL;
    char lpfile[BUFSIZ];

    if ((svc == NULL) || (printer == NULL) || (files == NULL) ||
        (job == NULL))
        return (PAPI_BAD_ARGUMENT);

    if (job_ticket != NULL)
        return (PAPI_OPERATION_NOT_SUPPORTED);

    if (files != NULL)
        for (file_no = 0; files[file_no] != NULL; file_no++) {
            if (access(files[file_no], R_OK) < 0) {
                detailed_error(svc,
                    gettext("Cannot access file: %s: %s"),
                    files[file_no], strerror(errno));
                return (PAPI_BAD_ARGUMENT);
            }
            if (stat(files[file_no], &statbuf) < 0) {
                detailed_error(svc,
                    gettext("Cannot access file: %s: %s"),
                    files[file_no], strerror(errno));
                return (PAPI_DOCUMENT_ACCESS_ERROR);
            }
            if (statbuf.st_size == 0) {
                detailed_error(svc,
                    gettext("Zero byte (empty) file: %s"),
                    files[file_no]);
                return (PAPI_BAD_ARGUMENT);
            }
        }

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    /* file_no + 1 for the control file (-0) */
    status = lpsched_alloc_files(svc, file_no + 1, &request_id);
    if (status != PAPI_OK)
        return (status);

    request = create_request(svc, (char *)printer,
        (papi_attribute_t **)job_attributes);

    for (i = 0; files[i] != NULL; i++) {
        papi_status_t status;
        snprintf(lpfile, sizeof (lpfile), "%s%s-%d",
            "/var/spool/lp/temp/", request_id, i+1);
        status = copy_file(files[i], lpfile);
        if (status != PAPI_OK) {
            detailed_error(svc,
                gettext("unable to copy: %s -> %s: %s"),
                files[i], lpfile, strerror(errno));
                freerequest(request);
            return (PAPI_DEVICE_ERROR);
        }
        addlist(&(request->file_list), lpfile);
    }

#ifdef LP_USE_PAPI_ATTR
    /*
     * store the job attributes in the PAPI job attribute file that was
     * created by lpsched_alloc_files(), the attributes will then pass
     * through lpsched and be given to the slow-filters and the printer's
     * interface script to process them
     */
    snprintf(lpfile, sizeof (lpfile), "%s%s-%s",
        "/var/spool/lp/temp/", request_id, LP_PAPIATTRNAME);
    status = psm_copy_attrsToFile(job_attributes, lpfile);
    if (status != PAPI_OK) {
        detailed_error(svc, "unable to copy attributes to file: %s: %s",
            lpfile, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }
#endif

    /* store the meta-data file */
    snprintf(lpfile, sizeof (lpfile), "%s-0", request_id);
    if (putrequest(lpfile, request) < 0) {
        detailed_error(svc, gettext("unable to save request: %s: %s"),
            lpfile, strerror(errno));
        freerequest(request);
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_commit_job(svc, lpfile, &tmp);
    if (status != PAPI_OK) {
        unlink(lpfile);
        freerequest(request);
        return (status);
    }

    lpsched_request_to_job_attributes(request, j);
    freerequest(request);

    if ((c = strrchr(tmp, '-')) != NULL)
        c++;
    papiAttributeListAddInteger(&j->attributes, PAPI_ATTR_REPLACE,
        "job-id", atoi(c));
    papiAttributeListAddString(&j->attributes, PAPI_ATTR_REPLACE,
        "job-uri", tmp);

    return (PAPI_OK);
}

papi_status_t
papiJobSubmitByReference(papi_service_t handle, char *printer,
        papi_attribute_t **job_attributes,
        papi_job_ticket_t *job_ticket,
        char **files, papi_job_t *job)
{
    service_t *svc = handle;
    struct stat statbuf;
    job_t *j;
    int file_no;
    short status;
    char *request_id = NULL;
    REQUEST *request;
    char *c;
    char *tmp = NULL;
    char lpfile[BUFSIZ];
    char **file_list = NULL;

    if ((svc == NULL) || (printer == NULL) || (files == NULL) ||
        (job == NULL))
        return (PAPI_BAD_ARGUMENT);

    if (job_ticket != NULL)
        return (PAPI_OPERATION_NOT_SUPPORTED);

    if (files != NULL)
        for (file_no = 0; files[file_no] != NULL; file_no++) {
            if (access(files[file_no], R_OK) < 0) {
                detailed_error(svc,
                    gettext("Cannot access file: %s: %s"),
                    files[file_no], strerror(errno));
                return (PAPI_DOCUMENT_ACCESS_ERROR);
            }
            if (stat(files[file_no], &statbuf) < 0) {
                detailed_error(svc,
                    gettext("Cannot access file: %s: %s"),
                    files[file_no], strerror(errno));
                return (PAPI_DOCUMENT_ACCESS_ERROR);
            }
            if (statbuf.st_size == 0) {
                detailed_error(svc,
                    gettext("Zero byte (empty) file: %s"),
                    files[file_no]);
                return (PAPI_BAD_ARGUMENT);
            }

            if (files[file_no][0] != '/') {
                char path[MAXPATHLEN];

                if (getcwd(path, sizeof (path)) == NULL) {
                    detailed_error(svc, gettext(
                        "getcwd for file: %s: %s"),
                        files[file_no],
                        strerror(errno));
                    return (PAPI_DOCUMENT_ACCESS_ERROR);
                }
                strlcat(path, "/", sizeof (path));
                if (strlcat(path, files[file_no], sizeof (path))
                    >= sizeof (path)) {
                    detailed_error(svc, gettext(
                        "pathname too long: %s"),
                        files[file_no]);
                    return (PAPI_DOCUMENT_ACCESS_ERROR);
                }
                addlist(&file_list, path);
            } else
                addlist(&file_list, (char *)files[file_no]);
        }

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    /* 1 for the control file (-0) */
    status = lpsched_alloc_files(svc, 1, &request_id);
    if (status != PAPI_OK)
        return (status);

    request = create_request(svc, (char *)printer,
        (papi_attribute_t **)job_attributes);
    request->file_list = file_list;

#ifdef LP_USE_PAPI_ATTR
    /*
     * store the job attributes in the PAPI job attribute file that was
     * created by lpsched_alloc_files(), the attributes will then pass
     * through lpsched and be given to the slow-filters and the printer's
     * interface script to process them
     */
    snprintf(lpfile, sizeof (lpfile), "%s%s-%s",
        "/var/spool/lp/temp/", request_id, LP_PAPIATTRNAME);
    status = psm_copy_attrsToFile(job_attributes, lpfile);
    if (status != PAPI_OK) {
        detailed_error(svc, "unable to copy attributes to file: %s: %s",
            lpfile, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }
#endif

    /* store the meta-data file */
    snprintf(lpfile, sizeof (lpfile), "%s-0", request_id);
    if (putrequest(lpfile, request) < 0) {
        detailed_error(svc, gettext("unable to save request: %s: %s"),
            lpfile, strerror(errno));
        freerequest(request);
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_commit_job(svc, lpfile, &tmp);
    if (status != PAPI_OK) {
        unlink(lpfile);
        freerequest(request);
        return (status);
    }

    lpsched_request_to_job_attributes(request, j);

    freerequest(request);

    if ((c = strrchr(tmp, '-')) != NULL)
        c++;
    papiAttributeListAddInteger(&j->attributes, PAPI_ATTR_REPLACE,
        "job-id", atoi(c));
    papiAttributeListAddString(&j->attributes, PAPI_ATTR_REPLACE,
        "job-uri", tmp);

    return (PAPI_OK);
}

papi_status_t
papiJobValidate(papi_service_t handle, char *printer,
        papi_attribute_t **job_attributes,
        papi_job_ticket_t *job_ticket,
        char **files, papi_job_t *job)
{
    papi_status_t status;
    papi_attribute_t **attributes = NULL;
    int i;

    papiAttributeListAddString(&attributes, PAPI_ATTR_REPLACE,
        "job-hold-until", "indefinite");
    for (i = 0; job_attributes[i]; i++)
        list_append(&attributes, job_attributes[i]);

    status = papiJobSubmitByReference(handle, printer,
        (papi_attribute_t **)attributes,
        job_ticket, files, job);
    if (status == PAPI_OK) {
        int id = papiJobGetId(*job);

        if (id != -1)
            papiJobCancel(handle, printer, id);
    }

    attributes[1] = NULL;   /* after attr[0], they are in another list */
    papiAttributeListFree(attributes);

    return (status);
}

papi_status_t
papiJobStreamOpen(papi_service_t handle, char *printer,
        papi_attribute_t **job_attributes,
        papi_job_ticket_t *job_ticket, papi_stream_t *stream)
{
    papi_status_t status;
    service_t *svc = handle;
    job_stream_t *s = NULL;
    char *request_id = NULL;
    char lpfile[BUFSIZ];

    if ((svc == NULL) || (printer == NULL) || (stream == NULL))
        return (PAPI_BAD_ARGUMENT);

    if (job_ticket != NULL)
        return (PAPI_OPERATION_NOT_SUPPORTED);

    if ((*stream = s = calloc(1, sizeof (*s))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    /* 1 for data, 1 for the meta-data (-0) */
    status = lpsched_alloc_files(svc, 2, &request_id);
    if (status != PAPI_OK)
        return (status);

    papiAttributeListAddString(&job_attributes, PAPI_ATTR_EXCL,
        "job-name", "standard input");

    s->request = create_request(svc, (char *)printer,
        (papi_attribute_t **)job_attributes);
    snprintf(lpfile, sizeof (lpfile), "/var/spool/lp/temp/%s-1",
        request_id);
    s->fd = open(lpfile, O_WRONLY);
    addlist(&(s->request->file_list), lpfile);

#ifdef LP_USE_PAPI_ATTR
    /*
     * store the job attributes in the PAPI job attribute file that was
     * created by lpsched_alloc_files(), the attributes will then pass
     * through lpsched and be given to the slow-filters and the printer's
     * interface script to process them
     */
    snprintf(lpfile, sizeof (lpfile), "%s%s-%s",
        "/var/spool/lp/temp/", request_id, LP_PAPIATTRNAME);
    status = psm_copy_attrsToFile(job_attributes, lpfile);
    if (status != PAPI_OK) {
        detailed_error(svc, "unable to copy attributes to file: %s: %s",
            lpfile, strerror(errno));
        close(s->fd);
        free(s);
        return (PAPI_DEVICE_ERROR);
    }
#endif

    /* store the meta-data file */
    snprintf(lpfile, sizeof (lpfile), "%s-0", request_id);
    s->meta_data_file = strdup(lpfile);
    if (putrequest(lpfile, s->request) < 0) {
        detailed_error(svc, gettext("unable to save request: %s: %s"),
            lpfile, strerror(errno));
        s->request = NULL;
        return (PAPI_DEVICE_ERROR);
    }

    return (PAPI_OK);
}

papi_status_t
papiJobStreamWrite(papi_service_t handle,
        papi_stream_t stream, void *buffer, size_t buflen)
{
    service_t *svc = handle;
    job_stream_t *s = stream;

    if ((svc == NULL) || (stream == NULL) || (buffer == NULL))
        return (PAPI_BAD_ARGUMENT);

    if (write(s->fd, buffer, buflen) != buflen)
        return (PAPI_DEVICE_ERROR);

    return (PAPI_OK);
}
papi_status_t
papiJobStreamClose(papi_service_t handle,
        papi_stream_t stream, papi_job_t *job)
{
    papi_status_t status = PAPI_OK;
    service_t *svc = handle;
    job_stream_t *s = stream;
    job_t *j = NULL;
    char *tmp = NULL, *c;

    if ((svc == NULL) || (stream == NULL) || (job == NULL))
        return (PAPI_BAD_ARGUMENT);

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    close(s->fd);

    lpsched_request_to_job_attributes(s->request, j);

    if (s->meta_data_file != NULL) {
        status = lpsched_commit_job(svc, s->meta_data_file, &tmp);
        if (status != PAPI_OK) {
            unlink(s->meta_data_file);
            return (status);
        }
        if ((c = strrchr(tmp, '-')) != NULL)
            c++;
        papiAttributeListAddInteger(&j->attributes, PAPI_ATTR_REPLACE,
            "job-id", atoi(c));
        papiAttributeListAddString(&j->attributes, PAPI_ATTR_REPLACE,
            "job-uri", tmp);
        free(s->meta_data_file);
    }
    freerequest(s->request);
    free(s);

    return (PAPI_OK);
}

papi_status_t
papiJobQuery(papi_service_t handle, char *printer, int32_t job_id,
        char **requested_attrs,
        papi_job_t *job)
{
    service_t *svc = handle;
    job_t *j;
    char *dest;
    char req_id[32];
    short rc;
    char *form = NULL,
        *request_id = NULL,
        *charset = NULL,
        *user = NULL,
        *slabel = NULL,
        *file = NULL;
    time_t date = 0;
    size_t size = 0;
    short  rank = 0,
        state = 0;

    if ((handle == NULL) || (printer == NULL) || (job_id < 0))
        return (PAPI_BAD_ARGUMENT);

    dest = printer_name_from_uri_id(printer, job_id);
    snprintf(req_id, sizeof (req_id), "%s-%d", dest, job_id);
    free(dest);

    rc = snd_msg(svc, S_INQUIRE_REQUEST_RANK, 0, "", "", req_id, "", "");
    if (rc < 0)
        return (PAPI_SERVICE_UNAVAILABLE);

    if (rcv_msg(svc, R_INQUIRE_REQUEST_RANK, &rc, &request_id,
        &user, &slabel, &size, &date, &state, &dest, &form,
        &charset, &rank, &file) < 0) {
        detailed_error(svc,
            gettext("failed to read response from scheduler"));
        return (PAPI_DEVICE_ERROR);
    }

    if ((request_id == NULL) || (request_id[0] == NULL))
        return (PAPI_NOT_FOUND);

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    snprintf(req_id, sizeof (req_id), "%d-0", job_id);
    lpsched_read_job_configuration(svc, j, req_id);

    job_status_to_attributes(j, request_id, user, slabel, size, date, state,
        dest, form, charset, rank, file);

    return (PAPI_OK);
}

papi_status_t
papiJobMove(papi_service_t handle, char *printer, int32_t job_id,
        char *destination)
{
    papi_status_t result = PAPI_OK;
    long bits;
    service_t *svc = handle;
    char req_id[64];
    char *queue;
    char *user = NULL;

    if ((svc == NULL) || (printer == NULL) || (job_id < 0) ||
        (destination == NULL))
        return (PAPI_BAD_ARGUMENT);

    queue = printer_name_from_uri_id(printer, job_id);
    snprintf(req_id, sizeof (req_id), "%s-%d", queue, job_id);
    free(queue);

    if (papiAttributeListGetString(svc->attributes, NULL, "user-name",
        &user) == PAPI_OK) {
        REQUEST *r = getrequest(req_id);

        if ((r != NULL) && (r->user != NULL) &&
            (strcmp(r->user, user) != 0))
            result = PAPI_NOT_AUTHORIZED;
        freerequest(r);
    }

    if (result == PAPI_OK) {
        short status = MOK;
        char *dest = printer_name_from_uri_id(destination, -1);

        if ((snd_msg(svc, S_MOVE_REQUEST, req_id, dest) < 0) ||
            (rcv_msg(svc, R_MOVE_REQUEST, &status, &bits) < 0))
            status = MTRANSMITERR;

        free(dest);

        result = lpsched_status_to_papi_status(status);
    }

    return (result);
}

papi_status_t
papiJobCancel(papi_service_t handle, char *printer, int32_t job_id)
{
    papi_status_t result = PAPI_OK;
    service_t *svc = handle;
    char req_id[64];
    char *dest;
    char *user = NULL;

    if ((svc == NULL) || (printer == NULL) || (job_id < 0))
        return (PAPI_BAD_ARGUMENT);

    dest = printer_name_from_uri_id(printer, job_id);
    snprintf(req_id, sizeof (req_id), "%s-%d", dest, job_id);
    free(dest);

    if (papiAttributeListGetString(svc->attributes, NULL, "user-name",
        &user) == PAPI_OK) {
        REQUEST *r = getrequest(req_id);

        if ((result = authorized(handle, job_id)) != PAPI_OK)
            result = PAPI_NOT_AUTHORIZED;

        if ((r != NULL) && (r->user != NULL) &&
            (strcmp(r->user, user) != 0))
            result = PAPI_NOT_AUTHORIZED;
        freerequest(r);
    }

    if (result == PAPI_OK) {
        short status = MOK;

        if ((snd_msg(svc, S_CANCEL_REQUEST, req_id) < 0) ||
            (rcv_msg(svc, R_CANCEL_REQUEST, &status) < 0))
            status = MTRANSMITERR;

        result = lpsched_status_to_papi_status(status);
    }

    return (result);
}

papi_status_t
hold_release_job(papi_service_t handle, char *printer,
        int32_t job_id, int flag)
{
    papi_status_t status;
    service_t *svc = handle;
    REQUEST *r = NULL;
    char *file;
    char *dest;

    if ((svc == NULL) || (printer == NULL) || (job_id < 0))
        return (PAPI_BAD_ARGUMENT);

    if ((status = authorized(svc, job_id)) != PAPI_OK)
        return (status);

    dest = printer_name_from_uri_id(printer, job_id);
    status = lpsched_start_change(svc, dest, job_id, &file);
    if (status != PAPI_OK)
        return (status);

    if ((r = getrequest(file)) != NULL) {
        r->actions &= ~ACT_RESUME;
        switch (flag) {
        case 0:
            r->actions |= ACT_HOLD;
            break;
        case 1:
            r->actions |= ACT_RESUME;
            break;
        case 2:
            r->actions |= ACT_IMMEDIATE;
            break;
        }
        if (putrequest(file, r) < 0) {
            detailed_error(svc,
                gettext("failed to write job: %s: %s"),
                file, strerror(errno));
            freerequest(r);
            return (PAPI_DEVICE_ERROR);
        }
        freerequest(r);
    } else {
        detailed_error(svc, gettext("failed to read job: %s: %s"),
            file, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_end_change(svc, dest, job_id);

    return (status);
}

papi_status_t
papiJobHold(papi_service_t handle, char *printer, int32_t job_id)
{
    return (hold_release_job(handle, printer, job_id, 0));
}

papi_status_t
papiJobRelease(papi_service_t handle, char *printer, int32_t job_id)
{
    return (hold_release_job(handle, printer, job_id, 1));
}

papi_status_t
papiJobPromote(papi_service_t handle, char *printer, int32_t job_id)
{
    return (hold_release_job(handle, printer, job_id, 2));
}

papi_status_t
papiJobModify(papi_service_t handle, char *printer, int32_t job_id,
        papi_attribute_t **attributes, papi_job_t *job)
{
    papi_status_t status;
    job_t *j = NULL;
    service_t *svc = handle;
    char *file = NULL;
    char *dest;
    REQUEST *r = NULL;
    char lpfile[BUFSIZ];
    int32_t job_id_actual;

    if ((svc == NULL) || (printer == NULL) || (job_id < 0) ||
        (attributes == NULL))
        return (PAPI_BAD_ARGUMENT);

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    dest = printer_name_from_uri_id(printer, job_id);

    /*
     * job-id might be job-id-requested
     * If it is job-id-requested then we need to
     * look for corresponding job-id
     */
    job_id_actual = check_job_id(svc, printer, job_id);

    if (job_id_actual < 0) {
        status = PAPI_NOT_FOUND;
        detailed_error(svc,
            "failed to initiate change for job (%s-%d): %s",
            dest, job_id, "no such resource");
        return (status);
    }

    status = lpsched_start_change(svc, dest, job_id_actual, &file);
    if (status != PAPI_OK)
        return (status);

    if ((r = getrequest(file)) != NULL) {
        job_attributes_to_lpsched_request(handle, r,
            (papi_attribute_t **)attributes);
#ifdef LP_USE_PAPI_ATTR
        /*
         * store the job attributes in the PAPI job attribute file
         * that was created by the original job request. We need to
         * modify the attributes in the file as per the new attributes
         */
        snprintf(lpfile, sizeof (lpfile), "%s%d-%s",
            "/var/spool/lp/temp/", job_id_actual, LP_PAPIATTRNAME);
        status = psm_modifyAttrsFile(attributes, lpfile);
        if (status != PAPI_OK) {
            detailed_error(svc,
                "unable to modify the attributes file: %s: %s",
                lpfile, strerror(errno));
            return (PAPI_DEVICE_ERROR);
        }
#endif

        if (putrequest(file, r) < 0) {
            detailed_error(svc,
                gettext("failed to write job: %s: %s"),
                file, strerror(errno));
            freerequest(r);
            return (PAPI_DEVICE_ERROR);
        }
    } else {
        detailed_error(svc, gettext("failed to read job: %s: %s"),
            file, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_end_change(svc, dest, job_id_actual);
    lpsched_request_to_job_attributes(r, j);

    papiAttributeListAddInteger(&j->attributes, PAPI_ATTR_REPLACE,
        "job-id", job_id_actual);

    freerequest(r);

    return (status);
}

/*
 * Extension to PAPI, a variation of this is slated for post-1.0
 */
#define DUMMY_FILE  "/var/spool/lp/fifos/FIFO"

papi_status_t
papiJobCreate(papi_service_t handle, char *printer,
        papi_attribute_t **job_attributes,
        papi_job_ticket_t *job_ticket, papi_job_t *job)
{
    papi_status_t status;
    service_t *svc = handle;
    job_t *j = NULL;
    REQUEST *request;
    char *request_id = NULL;
    char *c;
    char *tmp = NULL;
    char metadata_file[MAXPATHLEN];

    if ((svc == NULL) || (printer == NULL) || (job == NULL))
        return (PAPI_BAD_ARGUMENT);

    if (job_ticket != NULL)
        return (PAPI_JOB_TICKET_NOT_SUPPORTED);

    if ((*job = j = calloc(1, sizeof (*j))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    /* 1 for the control file (-0) */
    status = lpsched_alloc_files(svc, 1, &request_id);
    if (status != PAPI_OK)
        return (status);

    /* convert the attributes to an lpsched REQUEST structure */
    request = create_request(svc, (char *)printer,
        (papi_attribute_t **)job_attributes);
    if (request == NULL)
        return (PAPI_TEMPORARY_ERROR);
    addlist(&request->file_list, DUMMY_FILE);   /* add a dummy file */
    request->actions |= ACT_HOLD;           /* hold the job */

#ifdef LP_USE_PAPI_ATTR
    /*
     * store the job attributes in the PAPI job attribute file that was
     * created by lpsched_alloc_files(), the attributes will then pass
     * through lpsched and be given to the slow-filters and the printer's
     * interface script to process them
     */
    snprintf(metadata_file, sizeof (metadata_file), "%s%s-%s",
        "/var/spool/lp/temp/", request_id, LP_PAPIATTRNAME);
    status = psm_copy_attrsToFile(job_attributes, metadata_file);
    if (status != PAPI_OK) {
        detailed_error(svc, "unable to copy attributes to file: %s: %s",
            metadata_file, strerror(errno));
        free(request_id);
        return (PAPI_DEVICE_ERROR);
    }
#endif

    /* store the REQUEST on disk */
    snprintf(metadata_file, sizeof (metadata_file), "%s-0", request_id);
    free(request_id);
    if (putrequest(metadata_file, request) < 0) {
        detailed_error(svc, gettext("unable to save request: %s: %s"),
            metadata_file, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_commit_job(svc, metadata_file, &tmp);
    if (status != PAPI_OK) {
        unlink(metadata_file);
        return (status);
    }

    lpsched_request_to_job_attributes(request, j);

    if ((c = strrchr(tmp, '-')) != NULL)
        c++;
    papiAttributeListAddInteger(&j->attributes, PAPI_ATTR_REPLACE,
        "job-id", atoi(c));
    papiAttributeListAddString(&j->attributes, PAPI_ATTR_REPLACE,
        "job-uri", tmp);

    return (PAPI_OK);
}

papi_status_t
papiJobCommit(papi_service_t handle, char *printer, int32_t id)
{
    papi_status_t status = PAPI_OK;
    service_t *svc = handle;
    REQUEST *r = NULL;
    char *metadata_file;
    char *dest;

    if ((svc == NULL) || (printer == NULL))
        return (PAPI_BAD_ARGUMENT);

    dest = printer_name_from_uri_id(printer, id);
    /* tell the scheduler that we want to change the job */
    status = lpsched_start_change(svc, dest, id, &metadata_file);
    if (status != PAPI_OK)
        return (status);

    if ((r = getrequest(metadata_file)) != NULL) {
        r->actions &= ~ACT_RESUME;
        r->actions |= ACT_RESUME;
        dellist(&r->file_list, DUMMY_FILE);

        if (putrequest(metadata_file, r) < 0) {
            detailed_error(svc,
                gettext("failed to write job: %s: %s"),
                metadata_file, strerror(errno));
            freerequest(r);
            return (PAPI_DEVICE_ERROR);
        }
    } else {
        detailed_error(svc, gettext("failed to read job: %s: %s"),
            metadata_file, strerror(errno));
        return (PAPI_DEVICE_ERROR);
    }

    status = lpsched_end_change(svc, dest, id);
    freerequest(r);

    return (status);
}

papi_status_t
papiJobStreamAdd(papi_service_t handle, char *printer, int32_t id,
        papi_stream_t *stream)
{
    papi_status_t status;
    service_t *svc = handle;
    job_stream_t *s = NULL;
    char *metadata_file = NULL;
    char *dest;
    char path[MAXPATHLEN];

    /* allocate space for the stream */
    if ((*stream = s = calloc(1, sizeof (*s))) == NULL)
        return (PAPI_TEMPORARY_ERROR);

    dest = printer_name_from_uri_id(printer, id);
    /* create/open data file (only root or lp can really do this */
    snprintf(path, sizeof (path), "/var/spool/lp/temp/%d-XXXXXX", id);
    if ((s->fd = mkstemp(path)) < 0) {
        detailed_error(svc, gettext("unable to create sink (%s): %s"),
            path, strerror(errno));
        free(s);
        return (PAPI_NOT_AUTHORIZED);
    }

    /* add data file to job */
    status = lpsched_start_change(svc, dest, id, &metadata_file);
    if (status != PAPI_OK) {
        close(s->fd);
        free(s);
        unlink(path);
        return (status);
    }

    if ((s->request = getrequest(metadata_file)) == NULL) {
        detailed_error(svc, gettext("unable to load request: %s: %s"),
            metadata_file, strerror(errno));
        close(s->fd);
        free(s);
        unlink(path);
        return (PAPI_NOT_POSSIBLE);
    }

    addlist(&(s->request->file_list), path);

    if (putrequest(metadata_file, s->request) < 0) {
        detailed_error(svc, gettext("unable to save request: %s: %s"),
            metadata_file, strerror(errno));
        close(s->fd);
        free(s);
        unlink(path);
        return (PAPI_NOT_POSSIBLE);
    }

    status = lpsched_end_change(svc, dest, id);

    if (status != PAPI_OK)
        return (status);

    return (PAPI_OK);
}