OpenSolaris_b135/lib/print/libipp-core/common/write.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 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
*/
/* $Id: write.c 146 2006-03-24 00:26:54Z njacobs $ */
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <inttypes.h>
#include <papi.h>
#include <ipp.h>
static int8_t
papi_attribute_to_ipp_type(papi_attribute_value_type_t type)
{
switch (type) {
case PAPI_INTEGER:
return (VTAG_INTEGER);
case PAPI_BOOLEAN:
return (VTAG_BOOLEAN);
case PAPI_RANGE:
return (VTAG_RANGE_OF_INTEGER);
case PAPI_RESOLUTION:
return (VTAG_RESOLUTION);
case PAPI_DATETIME:
return (VTAG_DATE_TIME);
case PAPI_STRING:
return (VTAG_TEXT_WITHOUT_LANGUAGE);
}
return (0);
}
static papi_status_t
papi_ipp_type_match(papi_attribute_value_type_t papi, int8_t ipp)
{
switch (papi) {
case PAPI_STRING:
switch (ipp) {
case VTAG_URI:
case VTAG_OCTET_STRING:
case VTAG_TEXT_WITHOUT_LANGUAGE:
case VTAG_URI_SCHEME:
case VTAG_CHARSET:
case VTAG_NATURAL_LANGUAGE:
case VTAG_MIME_MEDIA_TYPE:
case VTAG_NAME_WITHOUT_LANGUAGE:
case VTAG_KEYWORD:
break;
default:
return (PAPI_CONFLICT);
}
break;
case PAPI_INTEGER:
switch (ipp) {
case VTAG_ENUM:
case VTAG_INTEGER:
break;
default:
return (PAPI_CONFLICT);
}
break;
case PAPI_BOOLEAN:
if (ipp != VTAG_BOOLEAN)
return (PAPI_CONFLICT);
break;
case PAPI_RANGE:
if (ipp != VTAG_RANGE_OF_INTEGER)
return (PAPI_CONFLICT);
break;
case PAPI_RESOLUTION:
if (ipp != VTAG_RESOLUTION)
return (PAPI_CONFLICT);
break;
case PAPI_DATETIME:
if (ipp != VTAG_DATE_TIME)
return (PAPI_CONFLICT);
break;
case PAPI_COLLECTION:
/* don't need to match */
break;
}
return (PAPI_OK);
}
static papi_status_t
ipp_write_attribute(ipp_writer_t iwrite, void *fd, papi_attribute_t *attribute)
{
papi_status_t status;
papi_attribute_value_t **values;
int8_t type;
int i;
char *name;
name = attribute->name;
values = attribute->values;
if ((type = name_to_ipp_type(name)) == 0)
type = papi_attribute_to_ipp_type(attribute->type);
/* The types don't match, so don't send the attribute */
if ((status = papi_ipp_type_match(attribute->type, type)) != PAPI_OK)
return (status);
if (values == NULL) {
uint16_t length;
type = VTAG_UNSUPPORTED;
if (iwrite(fd, &type, 1) != 1)
return (PAPI_DEVICE_ERROR);
if (name != NULL) { /* first value gets named */
length = (uint16_t)htons(strlen(name));
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, name, strlen(name)) != strlen(name))
return (PAPI_DEVICE_ERROR);
}
length = (uint16_t)htons(0);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
return (PAPI_OK);
}
for (i = 0; values[i] != NULL; i++) {
papi_attribute_value_t *value = values[i];
uint16_t length = 0;
if (iwrite(fd, &type, 1) != 1)
return (PAPI_DEVICE_ERROR);
if (name != NULL) { /* first value gets named */
length = (uint16_t)htons(strlen(name));
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, name, strlen(name)) != strlen(name))
return (PAPI_DEVICE_ERROR);
name = NULL;
} else {
length = (uint16_t)htons(0);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
}
switch (attribute->type) {
case PAPI_STRING: {
char *v = (char *)value->string;
if (v != NULL) {
size_t str_length = strlen(v);
/*
* if the length is more than 16 bits can
* express, send what can be represented
* in 16 bits. IPP "strings" can only be
* that large.
*/
if (str_length > 0xFFFF)
str_length = 0xFFFF;
length = (uint16_t)htons(str_length);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, v, str_length) != str_length)
return (PAPI_DEVICE_ERROR);
} else
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
}
break;
case PAPI_BOOLEAN: {
int8_t v = (int8_t)value->boolean;
length = (uint16_t)htons(1);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &v, 1) != 1)
return (PAPI_DEVICE_ERROR);
}
break;
case PAPI_INTEGER: {
int32_t v = (int32_t)value->integer;
length = (uint16_t)htons(4);
v = (int32_t)htonl(v);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &v, 4) != 4)
return (PAPI_DEVICE_ERROR);
}
break;
case PAPI_RANGE: {
int32_t min = (int32_t)htonl((int)(value->range).lower),
max = (int32_t)htonl((int)(value->range).upper);
length = (uint16_t)htons(8);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &min, 4) != 4)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &max, 4) != 4)
return (PAPI_DEVICE_ERROR);
}
break;
case PAPI_RESOLUTION: {
int32_t x = (int)(value->resolution).xres,
y = (int)(value->resolution).yres;
int8_t units = (int8_t)(value->resolution).units;
length = (uint16_t)htons(9);
x = (int32_t)htonl(x);
y = (int32_t)htonl(y);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &x, 4) != 4)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &y, 4) != 4)
return (PAPI_DEVICE_ERROR);
if (iwrite(fd, &units, 1) != 1)
return (PAPI_DEVICE_ERROR);
}
break;
case PAPI_DATETIME: {
struct tm *v = gmtime(&value->datetime);
int8_t c;
uint16_t s;
length = (uint16_t)htons(11);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
s = (uint16_t)htons(v->tm_year + 1900);
if (iwrite(fd, &s, 2) != 2)
return (PAPI_DEVICE_ERROR);
c = v->tm_mon + 1;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = v->tm_mday;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = v->tm_hour;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = v->tm_min;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = v->tm_sec;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = /* v->deciseconds */ 0;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = /* v->utc_dir */ 0;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = /* v->utc_hours */ 0;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
c = /* v->utc_minutes */ 0;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
}
break;
default: {
/*
* If there is a value, it is not one of our
* types, so we couldn't use it anyway. We assume
* that it was an OOB type with no value
*/
length = (uint16_t)htons(0);
if (iwrite(fd, &length, 2) != 2)
return (PAPI_DEVICE_ERROR);
}
break;
}
}
return (PAPI_OK);
}
static papi_status_t
ipp_write_attribute_group(ipp_writer_t iwrite, void *fd, int8_t type,
papi_attribute_t **attributes)
{
papi_status_t result = PAPI_OK;
int i;
/* write group tag */
if (iwrite(fd, &type, 1) != 1)
return (PAPI_DEVICE_ERROR);
/* write values */
for (i = 0; ((attributes[i] != NULL) && (result == PAPI_OK)); i++)
result = ipp_write_attribute(iwrite, fd, attributes[i]);
return (result);
}
static papi_status_t
ipp_write_attribute_groups(ipp_writer_t iwrite, void *fd,
papi_attribute_t **groups)
{
papi_status_t result = PAPI_OK;
int8_t c;
for (c = DTAG_MIN; c <= DTAG_MAX; c++) {
papi_status_t status;
papi_attribute_t **group = NULL;
void *iter = NULL;
char name[32];
(void) ipp_tag_string(c, name, sizeof (name));
for (status = papiAttributeListGetCollection(groups, &iter,
name, &group);
((status == PAPI_OK) && (result == PAPI_OK));
status = papiAttributeListGetCollection(groups, &iter,
NULL, &group))
result = ipp_write_attribute_group(iwrite, fd,
c, group);
}
c = DTAG_END_OF_ATTRIBUTES;
if (iwrite(fd, &c, 1) != 1)
result = PAPI_DEVICE_ERROR;
return (result);
}
static papi_status_t
ipp_write_message_header(ipp_writer_t iwrite, void *fd,
papi_attribute_t **message)
{
int tmp;
int8_t c;
uint16_t s;
int32_t i;
/* write the version */
papiAttributeListGetInteger(message, NULL, "version-major", &tmp);
c = tmp;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
papiAttributeListGetInteger(message, NULL, "version-minor", &tmp);
c = tmp;
if (iwrite(fd, &c, 1) != 1)
return (PAPI_DEVICE_ERROR);
/* write the request/status code */
papiAttributeListGetInteger(message, NULL, "status-code", &tmp);
papiAttributeListGetInteger(message, NULL, "operation-id", &tmp);
s = (uint16_t)htons(tmp);
if (iwrite(fd, &s, 2) != 2)
return (PAPI_DEVICE_ERROR);
/* write the request id */
papiAttributeListGetInteger(message, NULL, "request-id", &tmp);
i = (uint32_t)htonl(tmp);
if (iwrite(fd, &i, 4) != 4)
return (PAPI_DEVICE_ERROR);
return (PAPI_OK);
}
papi_status_t
ipp_write_message(ipp_writer_t iwrite, void *fd, papi_attribute_t **message)
{
papi_status_t result;
if ((iwrite == NULL) || (fd == NULL) || (message == NULL))
return (PAPI_BAD_ARGUMENT);
result = ipp_write_message_header(iwrite, fd, message);
if (result == PAPI_OK)
result = ipp_write_attribute_groups(iwrite, fd, message);
return (result);
}