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

/* $Id: ipp-support.c 148 2006-04-25 16:54:17Z njacobs $ */


#include <papi_impl.h>
#include <stdlib.h>
#include <pwd.h>
#include <locale.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <md5.h>

#include <config-site.h>

#include <ipp.h>

static void ipp_add_printer_uri(service_t *svc, char *name,
                papi_attribute_t ***op);

papi_status_t
http_to_papi_status(http_status_t status)
{
        switch (status) {
        case HTTP_OK:
                return (PAPI_OK);
        case HTTP_BAD_REQUEST:
                return (PAPI_BAD_REQUEST);
        case HTTP_UNAUTHORIZED:
        case HTTP_FORBIDDEN:
                return (PAPI_NOT_AUTHORIZED);
        case HTTP_NOT_FOUND:
                return (PAPI_NOT_FOUND);
        case HTTP_GONE:
                return (PAPI_GONE);
        case HTTP_SERVICE_UNAVAILABLE:
                return (PAPI_SERVICE_UNAVAILABLE);
        default:
                return ((papi_status_t)status);
        }
}

papi_status_t
ipp_to_papi_status(uint16_t status)
{
        switch (status) {
        case IPP_OK:
                return (PAPI_OK);
        case IPP_OK_IGNORED_ATTRIBUTES:
                return (PAPI_OK);
        case IPP_OK_CONFLICTING_ATTRIBUTES:
                return (PAPI_OK);
        case IPP_OK_IGNORED_SUBSCRIPTIONS:
                return (PAPI_OK_IGNORED_SUBSCRIPTIONS);
        case IPP_OK_IGNORED_NOTIFICATIONS:
                return (PAPI_OK_IGNORED_NOTIFICATIONS);
        case IPP_CERR_BAD_REQUEST:
                return (PAPI_BAD_REQUEST);
        case IPP_CERR_FORBIDDEN:
                return (PAPI_FORBIDDEN);
        case IPP_CERR_NOT_AUTHENTICATED:
                return (PAPI_NOT_AUTHENTICATED);
        case IPP_CERR_NOT_AUTHORIZED:
                return (PAPI_NOT_AUTHORIZED);
        case IPP_CERR_NOT_POSSIBLE:
                return (PAPI_NOT_POSSIBLE);
        case IPP_CERR_TIMEOUT:
                return (PAPI_TIMEOUT);
        case IPP_CERR_NOT_FOUND:
                return (PAPI_NOT_FOUND);
        case IPP_CERR_GONE:
                return (PAPI_GONE);
        case IPP_CERR_REQUEST_ENTITY:
                return (PAPI_REQUEST_ENTITY);
        case IPP_CERR_REQUEST_VALUE:
                return (PAPI_REQUEST_VALUE);
        case IPP_CERR_DOCUMENT_FORMAT:
                return (PAPI_DOCUMENT_FORMAT);
        case IPP_CERR_ATTRIBUTES:
                return (PAPI_ATTRIBUTES);
        case IPP_CERR_URI_SCHEME:
                return (PAPI_URI_SCHEME);
        case IPP_CERR_CHARSET:
                return (PAPI_CHARSET);
        case IPP_CERR_CONFLICT:
                return (PAPI_CONFLICT);
        case IPP_CERR_COMPRESSION_NOT_SUPPORTED:
                return (PAPI_COMPRESSION_NOT_SUPPORTED);
        case IPP_CERR_COMPRESSION_ERROR:
                return (PAPI_COMPRESSION_ERROR);
        case IPP_CERR_DOCUMENT_FORMAT_ERROR:
                return (PAPI_DOCUMENT_FORMAT_ERROR);
        case IPP_CERR_DOCUMENT_ACCESS_ERROR:
                return (PAPI_DOCUMENT_ACCESS_ERROR);
        case IPP_CERR_ATTRIBUTES_NOT_SETTABLE:
                return (PAPI_ATTRIBUTES_NOT_SETTABLE);
        case IPP_CERR_IGNORED_ALL_SUBSCRIPTIONS:
                return (PAPI_IGNORED_ALL_SUBSCRIPTIONS);
        case IPP_CERR_TOO_MANY_SUBSCRIPTIONS:
                return (PAPI_TOO_MANY_SUBSCRIPTIONS);
        case IPP_CERR_IGNORED_ALL_NOTIFICATIONS:
                return (PAPI_IGNORED_ALL_NOTIFICATIONS);
        case IPP_CERR_PRINT_SUPPORT_FILE_NOT_FOUND:
                return (PAPI_PRINT_SUPPORT_FILE_NOT_FOUND);
        case IPP_SERR_INTERNAL:
                return (PAPI_INTERNAL_ERROR);
        case IPP_SERR_OPERATION_NOT_SUPPORTED:
                return (PAPI_OPERATION_NOT_SUPPORTED);
        case IPP_SERR_SERVICE_UNAVAILABLE:
                return (PAPI_SERVICE_UNAVAILABLE);
        case IPP_SERR_VERSION_NOT_SUPPORTED:
                return (PAPI_VERSION_NOT_SUPPORTED);
        case IPP_SERR_DEVICE_ERROR:
                return (PAPI_DEVICE_ERROR);
        case IPP_SERR_TEMPORARY_ERROR:
                return (PAPI_TEMPORARY_ERROR);
        case IPP_SERR_NOT_ACCEPTING:
                return (PAPI_NOT_ACCEPTING);
        case IPP_SERR_BUSY:
        case IPP_SERR_CANCELLED:
        default:
                return (PAPI_TEMPORARY_ERROR);
        }
}

void
ipp_initialize_request(service_t *svc, papi_attribute_t ***request,
                uint16_t operation)
{
        papiAttributeListAddInteger(request, PAPI_ATTR_EXCL,
            "version-major", 1);
        papiAttributeListAddInteger(request, PAPI_ATTR_EXCL,
            "version-minor", 1);
        papiAttributeListAddInteger(request, PAPI_ATTR_EXCL,
            "request-id", (short)lrand48());
        papiAttributeListAddInteger(request, PAPI_ATTR_EXCL,
            "operation-id", operation);
}

void
ipp_initialize_operational_attributes(service_t *svc, papi_attribute_t ***op,
                char *printer, int job_id)
{
        char *charset = "utf-8"; /* default to UTF-8 encoding */
        char *language = setlocale(LC_ALL, "");
        char *user = "nobody";
        struct passwd *pw = NULL;

        /*
         * All IPP requests must contain the following:
         *      attributes-charset              (UTF-8)
         *      attributes-natural-language     (our current locale)
         *      (object identifier)             printer-uri/job-id or job-uri
         *      requesting-user-name            (process user or none)
         */
        papiAttributeListAddString(op, PAPI_ATTR_EXCL,
            "attributes-charset", charset);

        papiAttributeListAddString(op, PAPI_ATTR_EXCL,
            "attributes-natural-language", language);

        if (printer != NULL)
                ipp_add_printer_uri(svc, printer, op);

        if ((printer != NULL) && (job_id >= 0))
                papiAttributeListAddInteger(op, PAPI_ATTR_EXCL,
                    "job-id", job_id);

        if ((pw = getpwuid(getuid())) != NULL)
                user = pw->pw_name;
        /*
         * if our euid is 0 "super user", we will allow the system supplied
         * user name to be overridden, if the requestor wants to.
         */
        if (geteuid() == 0) {
                if (svc->user != NULL)
                        user = svc->user;
        }
        papiAttributeListAddString(op, PAPI_ATTR_REPLACE,
            "requesting-user-name", user);
}

#ifndef OPID_CUPS_GET_DEFAULT      /* for servers that will enumerate */
#define OPID_CUPS_GET_DEFAULT      0x4001
#endif  /* OPID_CUPS_GET_DEFAULT */

static papi_status_t
_default_destination(service_t *svc, char **uri)
{
        papi_status_t result = PAPI_INTERNAL_ERROR;
        printer_t *p = NULL;
        papi_attribute_t **request = NULL, **op = NULL, **response = NULL;
        char *tmp = NULL;

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

        /* we must be connected to find the default destination */
        if (svc->connection == NULL)
                return (PAPI_NOT_POSSIBLE);

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

        ipp_initialize_request(svc, &request, OPID_CUPS_GET_DEFAULT);
        ipp_initialize_operational_attributes(svc, &op, NULL, -1);
        papiAttributeListAddString(&op, PAPI_ATTR_APPEND,
            "requested-attributes", "printer-uri-supported");
        papiAttributeListAddCollection(&request, PAPI_ATTR_REPLACE,
            "operational-attributes-group", op);
        papiAttributeListFree(op);
        result = ipp_send_request(svc, request, &response);
        papiAttributeListFree(request);

        op = NULL;
        papiAttributeListGetCollection(response, NULL,
            "printer-attributes-group", &op);

        if (uri != NULL) {
                char *tmp = NULL;

                papiAttributeListGetString(op, NULL, "printer-uri", &tmp);
                papiAttributeListGetString(op, NULL,
                    "printer-uri-supported", &tmp);
                if (tmp != NULL)
                        *uri = strdup(tmp);
        }

        papiAttributeListFree(response);

        return (result);
}

static void
ipp_add_printer_uri(service_t *svc, char *name, papi_attribute_t ***op)
{
        char *uri = name;
        char buf[BUFSIZ];
        uri_t *tmp = NULL;

        if (strstr(name, "://") == NULL) { /* not in URI form */
                if (strcmp(name, DEFAULT_DEST) != 0) {
                        /* not the "default" */
                        snprintf(buf, sizeof (buf), "%s/%s", svc->name, name);
                        uri = buf;
                } else
                        _default_destination(svc, &uri);
        }

        papiAttributeListAddString(op, PAPI_ATTR_EXCL, "printer-uri", uri);

        /* save the printer-uri's path to be used by http POST request */
        if ((uri_from_string(uri, &tmp) == 0) && (tmp != NULL)) {
                if (svc->post != NULL)
                        free(svc->post);
                svc->post = strdup(tmp->path);
                uri_free(tmp);
        }
}


/*
 * don't actually write anything, just add to the total size and return the
 * size of what would be written, so we can figure out how big the request
 * is going to be.
 */
static ssize_t
size_calculate(void *fd, void *buffer, size_t length)
{
        ssize_t *size = (ssize_t *)fd;

        *size += length;
        return (length);
}


static ssize_t
build_chunk(void *fd, void *buffer, size_t length)
{
        char **s1 = fd;

        memcpy(*s1, buffer, length);
        *s1 = *s1 + length;

        return (length);
}

ssize_t
ipp_request_write(void *fd, void *buffer, size_t length)
{
        service_t *svc = (service_t *)fd;

#ifdef DEBUG
        printf("ipp_request_write(0x%8.8x, 0x%8.8x, %d)\n", fd, buffer, length);
        httpDumpData(stdout, "ipp_request_write:", buffer, length);
#endif
        return (httpWrite(svc->connection, buffer, length));
}

ssize_t
ipp_request_read(void *fd, void *buffer, size_t length)
{
        service_t *svc = (service_t *)fd;
        ssize_t rc, i = length;
        char *p = buffer;

        while ((rc = httpRead(svc->connection, p, i)) != i) {
                if (rc == 0)
                        return (rc);
                if (rc < 0)
                        return (rc);
                i -= rc;
                p += rc;
        }
#ifdef DEBUG
        printf("ipp_request_read(0x%8.8x, 0x%8.8x, %d) = %d\n",
            fd, buffer, length, rc);
        httpDumpData(stdout, "ipp_request_read:", buffer, length);
#endif

        return (length);
}

papi_status_t
ipp_send_initial_request_block(service_t *svc, papi_attribute_t **request,
                ssize_t file_size)
{
        papi_status_t result = PAPI_OK;
        ssize_t chunk_size = 0;
        char length[32];
        void *chunk, *ptr;
        http_status_t status;

        /* calculate the request size */
        (void) ipp_write_message(&size_calculate, &chunk_size, request);

        /* Fill in the HTTP Header information */
        httpClearFields(svc->connection);
        if (svc->transfer_encoding == TRANSFER_ENCODING_CHUNKED)
                httpSetField(svc->connection, HTTP_FIELD_TRANSFER_ENCODING,
                    "chunked");
        else {
                sprintf(length, "%lu", (unsigned long)(file_size + chunk_size));
                httpSetField(svc->connection, HTTP_FIELD_CONTENT_LENGTH,
                    length);
        }
        httpSetField(svc->connection, HTTP_FIELD_CONTENT_TYPE,
            "application/ipp");
        httpSetField(svc->connection, HTTP_FIELD_AUTHORIZATION,
            svc->connection->authstring);

        /* flush any state information about this connection */
        httpFlush(svc->connection);

        /* if we have don't have a POST path, use the service uri path */
        if ((svc->post == NULL) && (svc->uri->path))
                svc->post = strdup(svc->uri->path);
        /* send the HTTP POST message for the IPP request */
        /* if the POST fails, return the error */
        status = httpPost(svc->connection, svc->post);
        if (status != 0)
                return (http_to_papi_status(status));

        if (httpCheck(svc->connection) != 0) {
                status = httpUpdate(svc->connection);
                if (status != HTTP_OK)
                        return (http_to_papi_status(status));
        }

        /* build the request chunk */
        chunk = ptr = calloc(1, chunk_size);
        result = ipp_write_message(&build_chunk, &ptr, request);
#ifdef DEBUG
        printf("request: %d (0x%x) bytes\n", chunk_size, chunk_size);
        httpDumpData(stdout, "request:", chunk, chunk_size);
#endif

        /* send the actual IPP request */
        if (ipp_request_write(svc, chunk, chunk_size) != chunk_size)
                result = PAPI_TEMPORARY_ERROR;
        free(chunk);

        if (httpCheck(svc->connection) != 0) {
                status = httpUpdate(svc->connection);
                if (status != HTTP_OK)
                        return (http_to_papi_status(status));
        }

        return (result);
}

static int
setAuthString(service_t *svc)
{
        http_t *http;
        char *user, *passphrase;
        char encoded[BUFSIZ];

        if ((svc == NULL) || (svc->connection == NULL) || (svc->name == NULL))
                return (-1);

        http = svc->connection;

        if (svc->user == NULL) {
                struct passwd *p;

                if ((p = getpwuid(getuid())) != NULL) {
                        user = p->pw_name;
                } else if ((user = getenv("LOGNAME")) == NULL)
                        user = getenv("USER");
                if (user == NULL)
                        user = "nobody";
        } else
                user = svc->user;

        /* if the passphrase is not set, use the Authentication Callback */
        if (((svc->password == NULL) || (svc->password[0] == '\0')) &&
            (svc->authCB != NULL))
                (svc->authCB)(svc, svc->app_data);
        passphrase = svc->password;

        /* if there is still no passphrase, we have to fail */
        if ((passphrase == NULL) || (passphrase[0] == '\0'))
                return (-1);

        if (strncmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE],
            "Basic", 5) == 0) {
                char plain[BUFSIZ];

                snprintf(plain, sizeof (plain), "%s:%s", user, passphrase);
                httpEncode64(encoded, plain);
                snprintf(http->authstring, sizeof (http->authstring),
                    "Basic %s", encoded);
        } else if (strncmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE],
            "Digest", 6) == 0) {
                char realm[HTTP_MAX_VALUE];
                char nonce[HTTP_MAX_VALUE];
                char line [BUFSIZ];
                char urp[128];
                char mr[128];
                char *uri = svc->post;

                httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE,
                    "realm", realm);
                httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE,
                    "nonce", nonce);

                snprintf(line, sizeof (line), "%s:%s:%s", user, realm,
                    passphrase);
                md5_calc(urp, line, strlen(line));

                snprintf(line, sizeof (line), "POST:%s", uri);
                md5_calc(mr, line, strlen(line));

                snprintf(line, sizeof (line), "%s:%s:%s", urp, mr, nonce);
                md5_calc(encoded, line, strlen(line));

                snprintf(http->authstring, sizeof (http->authstring),
                    "Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", "
                    "uri=\"%s\", response=\"%s\"", user, realm, nonce, uri,
                    encoded);
        }

        return (0);
}

papi_status_t
ipp_status_info(service_t *svc, papi_attribute_t **response)
{
        papi_attribute_t **operational = NULL;
        int32_t status = 0;

        papiAttributeListGetCollection(response, NULL,
            "operational-attributes-group", &operational);
        if (operational != NULL) {
                char *message = NULL;

                papiAttributeListGetString(response, NULL,
                    "status-message", &message);
                papiAttributeListAddString(&svc->attributes, PAPI_ATTR_REPLACE,
                    "detailed-status-message", message);
        }
        papiAttributeListGetInteger(response, NULL, "status-code", &status);

        return (ipp_to_papi_status(status));
}

papi_status_t
ipp_send_request_with_file(service_t *svc, papi_attribute_t **request,
                papi_attribute_t ***response, char *file)
{
        papi_status_t result = PAPI_OK;
        ssize_t size = 0;
        struct stat statbuf;
        int fd;

#ifdef DEBUG
        fprintf(stderr, "\nIPP-REQUEST: (%s)", (file ? file : ""));
        papiAttributeListPrint(stderr, request, "    ");
        putc('\n', stderr);
        fflush(stderr);
#endif

        /*
         * if we are sending a file, open it and include it's size in the
         * message size.
         */
        if (file != NULL) {
                if ((fd = open(file, O_RDONLY)) < 0) {
                        detailed_error(svc, "%s: %s", file, strerror(errno));
                        return (PAPI_DOCUMENT_ACCESS_ERROR);
                } else if (strcmp("standard input", file) != 0) {
                        if (stat(file, &statbuf) < 0) {
                                detailed_error(svc,
                                    gettext("Cannot access file: %s: %s"),
                                    file, strerror(errno));
                                return (PAPI_DOCUMENT_ACCESS_ERROR);
                        }
                        if (statbuf.st_size == 0) {
                                detailed_error(svc,
                                    "Zero byte (empty) file: %s", file);
                                return (PAPI_BAD_ARGUMENT);
                        }
                } else if (svc->transfer_encoding !=
                    TRANSFER_ENCODING_CHUNKED) {
                        struct stat st;

                        if (fstat(fd, &st) >= 0)
                                size = st.st_size;
                }
        }

        *response = NULL;
        while (*response == NULL) {
                http_status_t status = HTTP_CONTINUE;

                result = ipp_send_initial_request_block(svc, request, size);

                if (result == PAPI_OK) {
                        if (file != NULL) {
                                /* send the file contents if we have it */
                                int rc;
                                char buf[BUFSIZ];

                                lseek(fd, 0L, SEEK_SET);
                                while ((rc = read(fd, buf, sizeof (buf))) > 0) {
                                        if (ipp_request_write(svc, buf, rc)
                                            < rc) {
                                                break;
                                        }
                                }
                        }

                        (void) ipp_request_write(svc, "", 0);
                }

                /* update our connection info */
                while (status == HTTP_CONTINUE)
                        status = httpUpdate(svc->connection);

                if (status == HTTP_UNAUTHORIZED) {
                        httpFlush(svc->connection);
                        if ((svc->connection->authstring[0] == '\0') &&
                            (setAuthString(svc) == 0)) {
                                httpReconnect(svc->connection);
                                continue;
                        }
                } else if (status == HTTP_UPGRADE_REQUIRED) {
                        /*
                         * If the transport was built with TLS support, we can
                         * try to use it.
                         */
                        httpFlush(svc->connection);
                        httpReconnect(svc->connection);
                        httpEncryption(svc->connection, HTTP_ENCRYPT_REQUIRED);
                        continue;
                }

                if (status != HTTP_OK)
                        return (http_to_papi_status(status));

                /* read the IPP response */
                result = ipp_read_message(&ipp_request_read, svc, response,
                    IPP_TYPE_RESPONSE);

                if (result == PAPI_OK)
                        result = ipp_status_info(svc, *response);
#ifdef DEBUG
                fprintf(stderr, "\nIPP-RESPONSE: (%s) (%s)", (file ? file : ""),
                    papiStatusString(result));
                papiAttributeListPrint(stderr, *response, "    ");
                putc('\n', stderr);
                fflush(stderr);
#endif
        }

        return (result);
}

papi_status_t
ipp_send_request(service_t *svc, papi_attribute_t **request,
                papi_attribute_t ***response)
{
        return (ipp_send_request_with_file(svc, request, response, NULL));
}