path: root/usr/src/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);
}