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

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

/* $Id: ipp-listener.c 146 2006-03-24 00:26:54Z njacobs $ */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <assert.h>
#include <errno.h>
#include <syslog.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/systeminfo.h>

#include <papi.h>
#include <ipp-listener.h>
#include <uri.h>

typedef papi_status_t (ipp_handler_t)(papi_service_t svc,
                                        papi_attribute_t **request,
                                        papi_attribute_t ***response,
                                        ipp_reader_t iread, void *fd);

/*
 * protocol request handlers are inserted below.  The handler must be
 * declared extern immediately below this comment and then an entry
 * must be inserted in the "handlers" table a little further down.
 */
extern ipp_handler_t ipp_print_job;
extern ipp_handler_t ipp_validate_job;
extern ipp_handler_t ipp_create_job;
extern ipp_handler_t ipp_get_printer_attributes;
extern ipp_handler_t ipp_get_jobs;
extern ipp_handler_t ipp_pause_printer;
extern ipp_handler_t ipp_resume_printer;
extern ipp_handler_t ipp_disable_printer;
extern ipp_handler_t ipp_enable_printer;
extern ipp_handler_t ipp_purge_jobs;
extern ipp_handler_t ipp_send_document;
extern ipp_handler_t ipp_cancel_job;
extern ipp_handler_t ipp_get_job_attributes;
extern ipp_handler_t ipp_release_job;
extern ipp_handler_t ipp_hold_job;
extern ipp_handler_t ipp_restart_job;
extern ipp_handler_t ipp_set_job_attributes;
extern ipp_handler_t ipp_set_printer_attributes;
extern ipp_handler_t cups_get_default;
extern ipp_handler_t cups_get_printers;
extern ipp_handler_t cups_get_classes;
extern ipp_handler_t cups_accept_jobs;
extern ipp_handler_t cups_reject_jobs;
extern ipp_handler_t cups_move_job;

/* ARGSUSED0 */
static papi_status_t
default_handler(papi_service_t svc, papi_attribute_t **request,
                papi_attribute_t ***response, ipp_reader_t iread, void *fd)
{
        int result = (int)PAPI_INTERNAL_ERROR;

        if (response != NULL)
                (void) papiAttributeListGetInteger(*response, NULL,
                                        "status-code", &result);

        return ((papi_status_t)result);
}

static struct {
        int16_t id;
        char *name;
        ipp_handler_t *function;
        enum { OP_REQUIRED, OP_OPTIONAL, OP_VENDOR } type;
} handlers[] = {
        /* Printer Operations */
        { 0x0002, "print-job",                  ipp_print_job,  OP_REQUIRED },
        { 0x0003, "print-uri",                  NULL,           OP_OPTIONAL },
        { 0x0004, "validate-job",               ipp_validate_job,
                                                                OP_REQUIRED },
        { 0x0005, "create-job",                 ipp_create_job, OP_OPTIONAL },
        { 0x000a, "get-jobs",                   ipp_get_jobs,   OP_REQUIRED },
        { 0x000b, "get-printer-attributes",     ipp_get_printer_attributes,
                                                                OP_REQUIRED },
        { 0x0010, "pause-printer",              ipp_pause_printer,
                                                                OP_OPTIONAL },
        { 0x0011, "resume-printer",             ipp_resume_printer,
                                                                OP_OPTIONAL },
        { 0x0012, "purge-jobs",                 ipp_purge_jobs, OP_OPTIONAL },
        { 0x0013, "set-printer-attributes",     ipp_set_printer_attributes,
                                                                OP_OPTIONAL },
        { 0x0014, "set-job-attributes",         ipp_set_job_attributes,
                                                                OP_OPTIONAL },
        { 0x0022, "enable-printer",             ipp_enable_printer,
                                                                OP_OPTIONAL },
        { 0x0023, "disable-printer",            ipp_disable_printer,
                                                                OP_OPTIONAL },
        /* Job Operations */
        { 0x0006, "send-document",              ipp_send_document,
                                                                OP_OPTIONAL },
        { 0x0007, "send-uri",                   NULL,           OP_OPTIONAL },
        { 0x0008, "cancel-job",                 ipp_cancel_job, OP_REQUIRED },
        { 0x0009, "get-job-attributes",         ipp_get_job_attributes,
                                                                OP_REQUIRED },
        { 0x000c, "hold-job",                   ipp_hold_job,   OP_OPTIONAL },
        { 0x000d, "release-job",                ipp_release_job,
                                                                OP_OPTIONAL },
        { 0x000e, "restart-job",                ipp_restart_job,
                                                                OP_OPTIONAL },
        /* Other Operations */
        { 0x4001, "cups-get-default",           cups_get_default,
                                                                OP_VENDOR },
        { 0x4002, "cups-get-printers",          cups_get_printers,
                                                                OP_VENDOR },
        { 0x4005, "cups-get-classes",           cups_get_classes,
                                                                OP_VENDOR },
        { 0x4008, "cups-accept-jobs",           cups_accept_jobs,
                                                                OP_VENDOR },
        { 0x4009, "cups-reject-jobs",           cups_reject_jobs,
                                                                OP_VENDOR },
        { 0x400D, "cups-move-job",              cups_move_job,  OP_VENDOR },
        { 0, NULL, NULL, OP_VENDOR }
};

static int
ipp_operation_name_to_index(char *name)
{
        int i;

        for (i = 0; handlers[i].name != NULL; i++)
                if (strcasecmp(name, handlers[i].name) == 0)
                        return (i);

        return (-1);
}

static int
ipp_operation_id_to_index(int16_t id)
{
        int i;

        for (i = 0; handlers[i].name != NULL; i++)
                if (id == handlers[i].id)
                        return (i);

        return (-1);
}

static ipp_handler_t *
ipp_operation_handler(papi_attribute_t **request, papi_attribute_t ***response)
{
        int id = 0;
        int index;
        papi_attribute_t **ops = NULL;
        papi_status_t status;
        char configured = PAPI_FALSE;

        /* get the operation from the request */
        status = papiAttributeListGetInteger(request, NULL,
                                "operation-id", &id);
        if (status != PAPI_OK) {
                ipp_set_status(response, PAPI_BAD_ARGUMENT,
                        "no operation specified in request");
                return (default_handler);
        }

        /* find the operation in the handler table */
        index = ipp_operation_id_to_index(id);
#ifdef DEBUG
        if (index == -1)
                fprintf(stderr, "Operation: 0x%4.4x\n", id);
        else
                fprintf(stderr, "Operation: 0x%4.4x(%s)\n", id,
                        handlers[index].name);
        fflush(stderr);
#endif

        if ((index == -1) || (handlers[index].function == NULL)) {
                ipp_set_status(response, PAPI_OPERATION_NOT_SUPPORTED,
                        "operation (0x%4.4x) not implemented by server",
                        id);
                return (default_handler);
        }

        /* find the configured operations */
        status = papiAttributeListGetCollection(request, NULL,
                                "operations", &ops);
        if (status != PAPI_OK) {        /* this should not be possible */
                ipp_set_status(response, PAPI_INTERNAL_ERROR,
                        "sofware error, no operations configured");
                return (default_handler);
        }

        /* check if the requested operation is configured */
        status = papiAttributeListGetBoolean(ops, NULL,
                                handlers[index].name, &configured);
        if ((status != PAPI_OK) || (configured != PAPI_TRUE)) {
                ipp_set_status(response, PAPI_OPERATION_NOT_SUPPORTED,
                        "operation (%s 0x%4.4x) not enabled on server",
                        handlers[index].name, id);
                return (default_handler);
        }

        return (handlers[index].function);
}

static char
type_to_boolean(char *type)
{
        char result = PAPI_FALSE;

        if ((strcasecmp(type, "true") == 0) ||
            (strcasecmp(type, "yes") == 0) ||
            (strcasecmp(type, "on") == 0) ||
            (strcasecmp(type, "enable") == 0))
                result = PAPI_TRUE;

        return (result);
}

static papi_status_t
ipp_configure_required_operations(papi_attribute_t ***list, char boolean)
{
        papi_status_t result = PAPI_OK;
        int i;

        for (i = 0; ((result == PAPI_OK) && (handlers[i].name != NULL)); i++)
                if (handlers[i].type == OP_REQUIRED)
                        result = papiAttributeListAddBoolean(list,
                                        PAPI_ATTR_REPLACE, handlers[i].name,
                                        boolean);

        return (result);

}

static papi_status_t
ipp_configure_all_operations(papi_attribute_t ***list, char boolean)
{
        papi_status_t result = PAPI_OK;
        int i;

        for (i = 0; ((result == PAPI_OK) && (handlers[i].name != NULL)); i++)
                result = papiAttributeListAddBoolean(list, PAPI_ATTR_REPLACE,
                                handlers[i].name, boolean);

        return (result);
}

papi_status_t
ipp_configure_operation(papi_attribute_t ***list, char *operation, char *type)
{
        papi_status_t result = PAPI_OPERATION_NOT_SUPPORTED;
        char boolean = PAPI_FALSE;

        if ((list == NULL) || (operation == NULL) || (type == NULL))
                return (PAPI_BAD_ARGUMENT);

        boolean = type_to_boolean(type);

        if (strcasecmp(operation, "all") == 0) {
                result = ipp_configure_all_operations(list, boolean);
        } else if (strcasecmp(operation, "required") == 0) {
                result = ipp_configure_required_operations(list, boolean);
        } else if (ipp_operation_name_to_index(operation) != -1) {
                result = papiAttributeListAddBoolean(list, PAPI_ATTR_REPLACE,
                                                        operation, boolean);
        }

        return (result);
}

void
ipp_operations_supported(papi_attribute_t ***list, papi_attribute_t **request)
{
        papi_attribute_t **group = NULL;

        (void) papiAttributeListGetCollection(request, NULL,
                                "operations", &group);
        if (group != NULL) {
                int i;

                for (i = 0; handlers[i].name != NULL; i++) {
                        char boolean = PAPI_FALSE;
                        (void) papiAttributeListGetBoolean(group, NULL,
                                        handlers[i].name, &boolean);

                        if (boolean == PAPI_TRUE)
                                (void) papiAttributeListAddInteger(list,
                                        PAPI_ATTR_APPEND,
                                        "operations-supported",
                                        handlers[i].id);
                }
        }
}

static papi_status_t
ipp_initialize_response(papi_attribute_t **request,
                        papi_attribute_t ***response)
{
        papi_attribute_t **operational = NULL;
        int i;

        if ((request == NULL) || (response == NULL))
                return (PAPI_BAD_ARGUMENT);

        /* If the response was initialized, start over */
        if (*response != NULL) {
                papiAttributeListFree(*response);
                *response = NULL;
        }

        /* Add the basic ipp header information to the response */
        (void) papiAttributeListGetInteger(request, NULL, "version-major", &i);
        (void) papiAttributeListAddInteger(response, PAPI_ATTR_REPLACE,
                                        "version-major", i);
        (void) papiAttributeListGetInteger(request, NULL, "version-minor", &i);
        (void) papiAttributeListAddInteger(response, PAPI_ATTR_REPLACE,
                                        "version-minor", i);

        (void) papiAttributeListGetInteger(request, NULL, "request-id", &i);
        (void) papiAttributeListAddInteger(response, PAPI_ATTR_REPLACE,
                                        "request-id", i);

        /* Add a default operational attributes group to the response */
        (void) papiAttributeListAddString(&operational, PAPI_ATTR_EXCL,
                        "attributes-charset", "utf-8");
        (void) papiAttributeListAddString(&operational, PAPI_ATTR_EXCL,
                        "attributes-natural-language", "en-us");

        (void) papiAttributeListAddCollection(response, PAPI_ATTR_REPLACE,
                                "operational-attributes-group", operational);
        papiAttributeListFree(operational);

        return (PAPI_OK);
}

/* simplistic check for cyclical service references */
static int
cyclical_service_check(char *svc_name, int port)
{
        papi_attribute_t **list;
        char buf[BUFSIZ];
        uri_t *uri = NULL;
        char *s = NULL;

        /* was there a service_uri? */
        if (svc_name == NULL)
                return (0);

        if ((list = getprinterbyname(svc_name, NULL)) == NULL)
                return (0);     /* if it doesnt' resolve, we will fail later */

        papiAttributeListGetString(list, NULL, "printer-uri-supported", &s);
        if ((s == NULL) || (strcasecmp(svc_name, s) != 0))
                return (0);     /* they don't match */

        /* is it in uri form? */
        if (uri_from_string(s, &uri) < 0)
                return (0);

        if ((uri == NULL) || (uri->scheme == NULL) || (uri->host == NULL)) {
                uri_free(uri);
                return (0);
        }

        /* is it ipp form */
        if (strcasecmp(uri->scheme, "ipp") != 0) {
                uri_free(uri);
                return (0);
        }

        /* does the host match up */
        if (is_localhost(uri->host) != 0) {
                uri_free(uri);
                return (0);
        }

        /* does the port match our own */
        if (((uri->port == NULL) && (port != 631)) ||
            ((uri->port != NULL) && (atoi(uri->port) != port))) {
                uri_free(uri);
                return (0);
        }

        uri_free(uri);

        return (1);
}

static papi_status_t
print_service_connect(papi_service_t *svc, papi_attribute_t **request,
                papi_attribute_t ***response)
{
        papi_status_t status;
        papi_attribute_t **operational = NULL;
        char *printer_uri = NULL;
        char *svc_name = NULL;
        char *user = NULL;
        int port = 631;

        /* Get the operational attributes group from the request */
        (void) papiAttributeListGetCollection(request, NULL,
                                "operational-attributes-group", &operational);

        /* get the user name */
        (void) papiAttributeListGetString(request, NULL, "default-user", &user);
        (void) papiAttributeListGetString(operational, NULL,
                                "requesting-user-name", &user);

        /* get the printer or service name */
        (void) papiAttributeListGetString(request, NULL,
                                "default-service", &svc_name);
        get_printer_id(operational, &svc_name, NULL);

        /* get the port that we are listening on */
        (void) papiAttributeListGetInteger(request, NULL, "uri-port", &port);

        if (cyclical_service_check(svc_name, port) != 0) {
                status = PAPI_NOT_POSSIBLE;
                ipp_set_status(response, status, "printer-uri is cyclical");
                return (status);
        }

        status = papiServiceCreate(svc, svc_name, user, NULL, NULL,
                                        PAPI_ENCRYPT_NEVER, NULL);
        if (status != PAPI_OK) {
                ipp_set_status(response, status, "print service: %s",
                                papiStatusString(status));
                return (status);
        }

        /*
         * Trusted Solaris can't be trusting of intermediaries.  Pass
         * the socket connection to the print service to retrieve the
         * sensativity label off of a multi-level port.
         */
        {
                int fd = -1;

                (void) papiAttributeListGetInteger(request, NULL,
                                        "peer-socket", &fd);
                if (fd != -1)
                        papiServiceSetPeer(*svc, fd);
        }

        return (status);
}

papi_status_t
ipp_process_request(papi_attribute_t **request, papi_attribute_t ***response,
        ipp_reader_t iread, void *fd)
{
        papi_status_t result = PAPI_OK;

        ipp_initialize_response(request, response);

#ifdef DEBUG
        fprintf(stderr, "REQUEST:");
        papiAttributeListPrint(stderr, request, " %d  ", getpid());
        fprintf(stderr, "\n");
#endif

        /* verify that the request is "well-formed" */
        if ((result = ipp_validate_request(request, response)) == PAPI_OK) {
                papi_service_t svc = NULL;
                ipp_handler_t *handler;

                result = print_service_connect(&svc, request, response);
                handler = ipp_operation_handler(request, response);

                /* process the request */
                if ((result == PAPI_OK) && (handler != NULL))
                        result = (handler)(svc, request, response, iread, fd);
#ifdef DEBUG
                fprintf(stderr, "RESULT: %s\n", papiStatusString(result));
#endif
                papiServiceDestroy(svc);
        }

        (void) papiAttributeListAddInteger(response, PAPI_ATTR_EXCL,
                                "status-code", result);
        massage_response(request, *response);

#ifdef DEBUG
        fprintf(stderr, "RESPONSE:");
        papiAttributeListPrint(stderr, *response, " %d  ", getpid());
        fprintf(stderr, "\n");
#endif

        return (result);
}