OpenSolaris_b135/lib/print/libpapi-ipp/common/ipp-support.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 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));
}