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

/* $Id: service.c 172 2006-05-24 20:54:00Z njacobs $ */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*LINTLIBRARY*/

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <alloca.h>
#include <libintl.h>
#include <papi_impl.h>
#include <config-site.h>

static int
interposed_auth_callback(papi_service_t handle, void *app_data)
{
    int result = -1;
    service_t *svc = app_data;

    if (svc != NULL)
        result = svc->authCB(svc, svc->app_data);

    return (result);
}

static char *
default_service_uri(char *fallback)
{
    char *result = NULL;

    if (getuid() == geteuid())
        result = getenv("PAPI_SERVICE_URI");

    if (result == NULL) {
        char *cups;

        if ((cups = getenv("CUPS_SERVER")) != NULL) {
            char buf[BUFSIZ];

            snprintf(buf, sizeof (buf), "ipp://%s/printers/", cups);
            result = strdup(buf);
        }
    }

    if (result == NULL)
        result = fallback;

    return (result);
}

static char *
default_print_service()
{
    static char *result = NULL;

    if (result == NULL) {
        char *service_uri = default_service_uri(DEFAULT_SERVICE_URI);
        uri_t *uri = NULL;

        if (uri_from_string(service_uri, &uri) != -1)
            result = strdup(uri->scheme);

        if (uri != NULL)
            uri_free(uri);
    }

    return (result);
}

static papi_status_t
service_load(service_t *svc, char *name)
{
    papi_status_t result;
    char *scheme = default_print_service();

    if (svc->so_handle != NULL) /* already loaded */
        return (PAPI_OK);

    if (name == NULL)       /* no info, can't load yet */
        return (PAPI_OK);

    /* Lookup the printer in the configuration DB */
    svc->attributes = getprinterbyname((char *)name, NULL);

    if (svc->attributes != NULL) {
        char *tmp = NULL;

        /* Printer found (or was a URI), use the attribute data */
        papiAttributeListGetString(svc->attributes, NULL,
                    "printer-uri-supported", &tmp);
        if (tmp != NULL)
            svc->name = strdup(tmp);

        /* parse the URI and set the scheme(print service) */
        if (uri_from_string(svc->name, &svc->uri) != -1)
            scheme = (svc->uri)->scheme;

        /* override the scheme if it was in the attributes */
        papiAttributeListGetString(svc->attributes, NULL,
                    "print-service-module", &scheme);

    } else  /* not found, assume it is the actual print service name */
        scheme = name;

    result = psm_open(svc, scheme);
    switch (result) {
    case PAPI_OK:
        break;  /* no error */
    case PAPI_URI_SCHEME:
        result = PAPI_NOT_FOUND;
#ifdef DEBUG
        detailed_error(svc, "Unable to load service for: %s", name);
#endif
        break;
    default:    /* set the detailed message */
        detailed_error(svc, "Unable to load service (%s) for: %s",
                scheme, name);
    }

    return (result);
}

static papi_status_t
service_send_peer(service_t *svc)
{
    papi_status_t result = PAPI_OK;

    if ((svc->peer_fd != -1) && (svc->so_handle != NULL) &&
        (svc->svc_handle != NULL)) {
        papi_status_t (*f)();

        f = (papi_status_t (*)())psm_sym(svc, "papiServiceSetPeer");

        if (f != NULL)
            result = f(svc->svc_handle, svc->peer_fd);
    }

    return (result);
}

papi_status_t
service_connect(service_t *svc, char *name)
{
    papi_status_t result = PAPI_NOT_POSSIBLE;

    /* if there is no print service module loaded, try and load one. */
    if (svc->so_handle == NULL)
        result = service_load(svc, name);
    else if ((svc->name == NULL) && (name != NULL))
        svc->name = strdup(name);

    /*
     * the print service module is loaded, but we don't have a service
     * handle.
     */
    if (svc->so_handle != NULL) {
        papi_status_t (*f)();

        if (svc->svc_handle != NULL)    /* already connected? */
            return (PAPI_OK);

        f = (papi_status_t (*)())psm_sym(svc, "papiServiceCreate");

        if (f != NULL) {
            char *user = svc->user;
            char *password = svc->password;

            /* if no API user, try the URI user */
            if ((user == NULL) && (svc->uri != NULL))
                user = (svc->uri)->user;
            /* if no API password, try the URI password */
            if ((password == NULL) && (svc->uri != NULL))
                password = (svc->uri)->password;

            result = f(&svc->svc_handle, svc->name, user, password,
                    (svc->authCB ? interposed_auth_callback
                        : NULL),
                    svc->encryption, svc);
            (void) service_send_peer(svc);
        }
    }

    return (result);
}

papi_status_t
papiServiceCreate(papi_service_t *handle, char *service_name, char *user_name,
        char *password,
        int (*authCB)(papi_service_t svc, void *app_data),
        papi_encryption_t encryption, void *app_data)
{
    papi_status_t result = PAPI_NOT_POSSIBLE;
    service_t *svc = NULL;
    uri_t *u = NULL;

    if (handle == NULL)
        return (PAPI_BAD_ARGUMENT);

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

    svc->peer_fd = -1;

    if (user_name != NULL)
        svc->user = strdup(user_name);

    if (password != NULL)
        svc->password = strdup(password);

    svc->encryption = encryption;

    if (authCB != NULL)
        svc->authCB = authCB;

    if (app_data != NULL)
        svc->app_data = app_data;

    /* If not specified, get a "default" service from the environment */
    if (service_name == NULL)
        service_name = default_service_uri(NULL);

    if (service_name != NULL) {
        result = service_load(svc, service_name);
        /* if the psm loaded and the svc contains a URI, connect */
        if ((result == PAPI_OK) && (svc->uri != NULL))
            result = service_connect(svc, service_name);
    } else
        result = PAPI_OK;

    return (result);
}

void
papiServiceDestroy(papi_service_t handle)
{
    if (handle != NULL) {
        service_t *svc = handle;

        if (svc->so_handle != NULL) {
            if (svc->svc_handle != NULL) {
                void (*f)();

                f = (void (*)())psm_sym(svc,
                            "papiServiceDestroy");
                f(svc->svc_handle);
            }
            psm_close(svc->so_handle);
        }
        if (svc->attributes != NULL)
            papiAttributeListFree(svc->attributes);
        if (svc->name != NULL)
            free(svc->name);
        if (svc->user != NULL)
            free(svc->user);
        if (svc->password != NULL)
            free(svc->password);
        if (svc->uri != NULL)
            uri_free(svc->uri);

        free(handle);
    }
}

papi_status_t
papiServiceSetPeer(papi_service_t handle, int fd)
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;

        svc->peer_fd = fd;
        result = service_send_peer(svc);
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}

papi_status_t
papiServiceSetUserName(papi_service_t handle, char *user_name)
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_status_t (*f)();

        if (svc->user != NULL)
            free(svc->user);
        if (user_name != NULL)
            svc->user = strdup(user_name);
        f = (papi_status_t (*)())psm_sym(svc, "papiServiceSetUserName");
        if (f != NULL)
            result = f(svc->svc_handle, user_name);
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}

papi_status_t
papiServiceSetPassword(papi_service_t handle, char *password)
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_status_t (*f)();

        if (svc->password != NULL)
            free(svc->password);
        if (password != NULL)
            svc->password = strdup(password);
        f = (papi_status_t (*)())psm_sym(svc, "papiServiceSetPassword");
        if (f != NULL)
            result = f(svc->svc_handle, password);
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}

papi_status_t
papiServiceSetEncryption(papi_service_t handle, papi_encryption_t encryption)
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_status_t (*f)();

        svc->encryption = encryption;
        f = (papi_status_t (*)())psm_sym(svc,
                        "papiServiceSetEncryption");
        if (f != NULL)
            result = f(svc->svc_handle, encryption);
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}

papi_status_t
papiServiceSetAuthCB(papi_service_t handle,
        int (*authCB)(papi_service_t svc, void *app_data))
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_status_t (*f)();

        svc->authCB = authCB;
        f = (papi_status_t (*)())psm_sym(svc, "papiServiceSetAuthCB");
        if (f != NULL)
            result = f(svc->svc_handle, interposed_auth_callback);
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}


papi_status_t
papiServiceSetAppData(papi_service_t handle, void *app_data)
{
    papi_status_t result = PAPI_OK;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_status_t (*f)();

        svc->app_data = (void *)app_data;
    } else
        result = PAPI_BAD_ARGUMENT;

    return (result);
}

char *
papiServiceGetServiceName(papi_service_t handle)
{
    char *result = NULL;

    if (handle != NULL) {
        service_t *svc = handle;
        char *(*f)();

        f = (char *(*)())psm_sym(svc, "papiServiceGetServiceName");
        if (f != NULL)
            result = f(svc->svc_handle);
        if (result == NULL)
            result = svc->name;
    }

    return (result);
}

char *
papiServiceGetUserName(papi_service_t handle)
{
    char *result = NULL;

    if (handle != NULL) {
        service_t *svc = handle;
        char *(*f)();

        f = (char *(*)())psm_sym(svc, "papiServiceGetUserName");
        if (f != NULL)
            result = f(svc->svc_handle);
        if (result == NULL)
            result = svc->user;
    }

    return (result);
}

char *
papiServiceGetPassword(papi_service_t handle)
{
    char *result = NULL;

    if (handle != NULL) {
        service_t *svc = handle;
        char *(*f)();

        f = (char *(*)())psm_sym(svc, "papiServiceGetPassword");
        if (f != NULL)
            result = f(svc->svc_handle);
        if (result == NULL)
            result = svc->password;
    }

    return (result);
}

papi_encryption_t
papiServiceGetEncryption(papi_service_t handle)
{
    papi_encryption_t result = PAPI_ENCRYPT_NEVER;

    if (handle != NULL) {
        service_t *svc = handle;
        papi_encryption_t (*f)();

        f = (papi_encryption_t (*)())psm_sym(svc,
                        "papiServiceGetEncryption");
        if (f != NULL)
            result = f(svc->svc_handle);
        if (result == PAPI_ENCRYPT_NEVER)
            result = svc->encryption;
    }

    return (result);
}

void *
papiServiceGetAppData(papi_service_t handle)
{
    void *result = NULL;
    service_t *svc = handle;

    if (handle != NULL)
        result = svc->app_data;

    return (result);
}

papi_attribute_t **
papiServiceGetAttributeList(papi_service_t handle)
{
    papi_attribute_t **result = NULL;
    service_t *svc = handle;

    if (handle != NULL) {
        papi_attribute_t **(*f)();

        if (svc->so_handle == NULL) {
            char *uri = default_service_uri(DEFAULT_SERVICE_URI);

            if (service_connect(svc, uri) != PAPI_OK)
                return (NULL);
        }

        f = (papi_attribute_t **(*)())psm_sym(svc,
                    "papiServiceGetAttributeList");
        if (f != NULL)
            result = f(svc->svc_handle);
    } else
        result = svc->attributes;

    return (result);
}

char *
papiServiceGetStatusMessage(papi_service_t handle)
{
    char *result = NULL;
    service_t *svc = handle;

    if (handle != NULL) {
        char *(*f)();

        f = (char *(*)())psm_sym(svc, "papiServiceGetStatusMessage");
        if (f != NULL)
            result = f(svc->svc_handle);
    }
    if (result == NULL) {
        papiAttributeListGetString(svc->attributes, NULL,
                    "detailed-status-message", &result);
    }

    return (result);
}

void
detailed_error(service_t *svc, char *fmt, ...)
{
    if ((svc != NULL) && (fmt != NULL)) {
        va_list ap;
        size_t size;
        char *message = alloca(BUFSIZ);

        va_start(ap, fmt);
        /*
         * fill in the message.  If the buffer is too small, allocate
         * one that is large enough and fill it in.
         */
        if ((size = vsnprintf(message, BUFSIZ, fmt, ap)) >= BUFSIZ)
            if ((message = alloca(size)) != NULL)
                vsnprintf(message, size, fmt, ap);
        va_end(ap);

        papiAttributeListAddString(&svc->attributes, PAPI_ATTR_APPEND,
                    "detailed-status-message", message);
#ifdef DEBUG
        fprintf(stderr, "detailed_error(%s)\n", message);
#endif
    }
}