OpenSolaris_b135/lib/print/libipp-core/common/read.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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
*/
/* $Id: read.c 146 2006-03-24 00:26:54Z njacobs $ */
#pragma ident "%Z%%M% %I% %E% SMI"
#include <stdio.h>
#include <stdlib.h>
#include <alloca.h>
#include <string.h>
#include <stdarg.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <inttypes.h>
#include <papi.h>
#include <ipp.h>
#define _ipp_tag_string(id) ipp_tag_string((id), buf, sizeof (buf))
static papi_status_t
read_name_with_language(ipp_reader_t iread, void *fd,
papi_attribute_t ***message)
{
char *string;
uint16_t size;
/* read the language */
if (iread(fd, &size, 2) != 2) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"read failed: lang len\n");
return (PAPI_BAD_REQUEST);
}
size = (uint16_t)ntohs(size);
if ((string = alloca(size + 1)) == NULL) {
ipp_set_status(message, PAPI_TEMPORARY_ERROR,
"Memory allocation failed");
return (PAPI_TEMPORARY_ERROR);
}
if (iread(fd, string, size) != size) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"read failed: lang\n");
return (PAPI_BAD_REQUEST);
}
/* read the text */
if (iread(fd, &size, 2) != 2) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"read failed: text len\n");
return (PAPI_BAD_REQUEST);
}
size = (uint16_t)ntohs(size);
if ((string = alloca(size + 1)) == NULL) {
ipp_set_status(message, PAPI_TEMPORARY_ERROR,
"Memory allocation failed");
return (PAPI_TEMPORARY_ERROR);
}
if (iread(fd, string, size) != size) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"read failed: text\n");
return (PAPI_BAD_REQUEST);
}
return (PAPI_OK);
}
static struct {
int8_t ipp_type;
int8_t size;
} type_info[] = {
{ VTAG_INTEGER, 4 },
{ VTAG_ENUM, 4 },
{ VTAG_BOOLEAN, 1 },
{ VTAG_RANGE_OF_INTEGER, 8 },
{ VTAG_RESOLUTION, 9 },
{ VTAG_DATE_TIME, 11 },
{ DTAG_MIN, 0 }
};
/* verify that the IPP type and size are compatible */
static int
validate_length(int8_t type, int8_t size)
{
int i;
for (i = 0; type_info[i].ipp_type != DTAG_MIN; i++)
if (type_info[i].ipp_type == type)
return ((type_info[i].size == size) ? 0 : -1);
return (0);
}
/* convert tyep IPP type to a type that is marginally compatible */
static int8_t
base_type(int8_t i)
{
switch (i) {
case VTAG_ENUM:
case VTAG_INTEGER:
return (VTAG_INTEGER);
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:
return (VTAG_TEXT_WITHOUT_LANGUAGE);
case VTAG_BOOLEAN:
case VTAG_RANGE_OF_INTEGER:
case VTAG_DATE_TIME:
case VTAG_RESOLUTION:
default:
return (i);
}
}
/* verify that the IPP type is correct for the named attribute */
static papi_status_t
validate_type(char *name, int8_t type)
{
int8_t t = name_to_ipp_type(name);
if (t == 0) /* The attribute is not defined in the RFC */
return (PAPI_NOT_FOUND);
else if (t == type) /* The supplied type matched the RFC type */
return (PAPI_OK);
else { /* The supplied type doesn't match the RFC */
if (base_type(t) == base_type(type))
return (PAPI_OK);
return (PAPI_CONFLICT);
}
}
/* verify that the IPP value is within specification for the named attribute */
static int
validate_value(papi_attribute_t ***message, char *name, int8_t type, ...)
{
#define within(a, b, c) ((b >= a) && (b <= c))
va_list ap;
int rc = -1;
int min = min_val_len(type, name),
max = max_val_len(type, name);
char buf[64]; /* For _ipp_<...>_string() */
va_start(ap, type);
switch (type) {
case VTAG_ENUM:
case VTAG_INTEGER: {
int32_t i = (int32_t)va_arg(ap, int32_t);
if (within(min, i, max))
rc = 0;
else
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %d: out of range (%d - %d)", name,
_ipp_tag_string(type), i, min, max);
}
break;
case VTAG_BOOLEAN: {
int8_t v = (int8_t)va_arg(ap, int);
if (within(0, v, 1))
rc = 0;
else
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %d: out of range (0 - 1)", name,
_ipp_tag_string(type), v);
}
break;
case VTAG_RANGE_OF_INTEGER: {
int32_t lower = (int32_t)va_arg(ap, int32_t);
int32_t upper = (int32_t)va_arg(ap, int32_t);
if (within(min, lower, max) &&
within(min, upper, max))
rc = 0;
else
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %d - %d: out of range (%d - %d)", name,
_ipp_tag_string(type), lower, upper, min, max);
}
break;
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: {
char *v = (char *)va_arg(ap, char *);
if (strlen(v) < max)
rc = 0;
else
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %s: too long (max length: %d)", name,
_ipp_tag_string(type), v, max);
}
break;
case VTAG_KEYWORD: {
char *v = (char *)va_arg(ap, char *);
if (strlen(v) >= max)
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %s: too long (max length: %d)", name,
_ipp_tag_string(type), v, max);
else if (is_keyword(v) == 0)
ipp_set_status(message, PAPI_BAD_ARGUMENT,
"%s(%s): %s: invalid keyword", name,
_ipp_tag_string(type), v);
else
rc = 0;
}
break;
case VTAG_DATE_TIME:
case VTAG_RESOLUTION:
default:
rc = 0;
}
va_end(ap);
return (rc);
#undef within
}
/*
* read_attr_group() reads in enough of the message data to parse an entire
* attribute group. Since to determine that the group is finished you have to
* read the character that determines the type of the next group, this function
* must return that character, in order that our caller knows how to call us for
* the next group. Thus type is used both as an input parameter (the type of
* attribute group to read in) and an output parameter (the type of the next
* attribute group).
*/
static papi_status_t
ipp_read_attribute_group(ipp_reader_t iread, void *fd, int8_t *type,
papi_attribute_t ***message)
{
int8_t value_tag;
uint16_t name_length, value_length;
papi_attribute_t **attributes = NULL;
char *name = NULL;
int i;
char buf[64]; /* For _ipp_<...>_string() */
/*
* RFC2910 3.3 says we need to handle `An expected but missing
* "begin-attribute-group-tag" field. How?
*/
if (*type > DTAG_MAX) {
/* Scream bloody murder, or assign a new type? */
ipp_set_status(message, PAPI_BAD_REQUEST,
"Bad attribute group tag 0x%.2hx (%s)",
*type, _ipp_tag_string(*type));
return (PAPI_BAD_REQUEST);
}
/* This loops through *values* not *attributes*! */
for (i = 0; ; i++) {
papi_status_t valid = PAPI_OK;
if (iread(fd, &value_tag, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: value tag\n");
return (PAPI_BAD_REQUEST);
}
/* are we done with this group ? */
if (value_tag <= DTAG_MAX)
break;
if (iread(fd, &name_length, 2) != 2) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: name length\n");
return (PAPI_BAD_REQUEST);
}
name_length = (uint16_t)ntohs(name_length);
/* Not just another value for the previous attribute */
if (name_length != 0) {
if ((name = alloca(name_length + 1)) == NULL) {
ipp_set_status(message, PAPI_TEMPORARY_ERROR,
"alloca(): failed\n");
return (PAPI_TEMPORARY_ERROR);
}
(void) memset(name, 0, name_length + 1);
if (iread(fd, name, name_length) != name_length) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: name\n");
return (PAPI_BAD_REQUEST);
}
}
valid = validate_type(name, value_tag);
if ((valid != PAPI_OK) && (valid != PAPI_NOT_FOUND))
ipp_set_status(message, valid, "%s(%s): %s", name,
_ipp_tag_string(value_tag),
papiStatusString(valid));
if (iread(fd, &value_length, 2) != 2) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: value length\n");
return (PAPI_BAD_REQUEST);
}
value_length = (uint16_t)ntohs(value_length);
if (validate_length(value_tag, value_length) < 0) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"Bad value length (%d) for type %s",
value_length, _ipp_tag_string(value_tag));
return (PAPI_BAD_REQUEST);
}
switch (value_tag) {
case VTAG_INTEGER:
case VTAG_ENUM: {
int32_t v;
if (iread(fd, &v, value_length) != value_length) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: int/enum\n");
return (PAPI_BAD_REQUEST);
}
v = (int32_t)ntohl(v);
(void) validate_value(message, name, value_tag, v);
papiAttributeListAddInteger(&attributes,
PAPI_ATTR_APPEND, name, v);
}
break;
case VTAG_BOOLEAN: {
int8_t v;
if (iread(fd, &v, value_length) != value_length) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: boolean\n");
return (PAPI_BAD_REQUEST);
}
(void) validate_value(message, name, value_tag, v);
papiAttributeListAddBoolean(&attributes,
PAPI_ATTR_APPEND, name, v);
}
break;
case VTAG_RANGE_OF_INTEGER: {
int32_t min, max;
if (iread(fd, &min, 4) != 4) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: min\n");
return (PAPI_BAD_REQUEST);
}
if (iread(fd, &max, 4) != 4) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: max\n");
return (PAPI_BAD_REQUEST);
}
min = (int32_t)ntohl(min);
max = (int32_t)ntohl(max);
(void) validate_value(message, name, value_tag,
min, max);
papiAttributeListAddRange(&attributes, PAPI_ATTR_APPEND,
name, min, max);
}
break;
case VTAG_RESOLUTION: {
int32_t x, y;
int8_t units;
if (iread(fd, &x, 4) != 4) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: x\n");
return (PAPI_BAD_REQUEST);
}
if (iread(fd, &y, 4) != 4) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: y\n");
return (PAPI_BAD_REQUEST);
}
if (iread(fd, &units, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: units\n");
return (PAPI_BAD_REQUEST);
}
x = (int32_t)ntohl(x);
y = (int32_t)ntohl(y);
papiAttributeListAddResolution(&attributes,
PAPI_ATTR_APPEND, name, x, y,
(papi_resolution_unit_t)units);
}
break;
case VTAG_DATE_TIME: {
struct tm tm;
time_t v;
int8_t c;
uint16_t s;
(void) memset(&tm, 0, sizeof (tm));
if (iread(fd, &s, 2) != 2) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: year\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_year = (uint16_t)ntohs(s) - 1900;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: month\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_mon = c - 1;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: day\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_mday = c;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: hour\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_hour = c;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: minutes\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_min = c;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: seconds\n");
return (PAPI_BAD_REQUEST);
}
tm.tm_sec = c;
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: decisec\n");
return (PAPI_BAD_REQUEST);
}
/* tm.deciseconds = c; */
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: utc_dir\n");
return (PAPI_BAD_REQUEST);
}
/* tm.utc_dir = c; */
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: utc_hour\n");
return (PAPI_BAD_REQUEST);
}
/* tm.utc_hours = c; */
if (iread(fd, &c, 1) != 1) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: utc_min\n");
return (PAPI_BAD_REQUEST);
}
/* tm.utc_minutes = c; */
v = mktime(&tm);
(void) validate_value(message, name, value_tag, v);
papiAttributeListAddDatetime(&attributes,
PAPI_ATTR_APPEND, name, v);
}
break;
case VTAG_NAME_WITH_LANGUAGE:
case VTAG_TEXT_WITH_LANGUAGE:
/*
* we are dropping this because we don't support
* name with language at this time.
*/
(void) read_name_with_language(iread, fd, message);
break;
case VTAG_NAME_WITHOUT_LANGUAGE:
case VTAG_TEXT_WITHOUT_LANGUAGE:
case VTAG_URI:
case VTAG_KEYWORD:
case VTAG_CHARSET: {
char *v;
if ((v = calloc(1, value_length + 1)) == NULL) {
ipp_set_status(message, PAPI_TEMPORARY_ERROR,
"calloc(): failed\n");
return (PAPI_TEMPORARY_ERROR);
}
#ifdef NOTDEF
if (iread(fd, v, value_length) != value_length) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: stringy\n");
return (PAPI_BAD_REQUEST);
}
#else
{
int rc, i = value_length;
char *p = v;
while ((rc = iread(fd, p, i)) != i) {
if (rc <= 0) {
ipp_set_status(message,
PAPI_BAD_REQUEST,
"bad read: stringy\n");
return (PAPI_BAD_REQUEST);
}
i -= rc;
p += rc;
}
}
#endif
(void) validate_value(message, name, value_tag, v);
papiAttributeListAddString(&attributes,
PAPI_ATTR_APPEND, name, v);
}
break;
case VTAG_UNKNOWN:
case VTAG_NOVALUE:
case VTAG_UNSUPPORTED:
papiAttributeListAddValue(&attributes, PAPI_ATTR_EXCL,
name, PAPI_COLLECTION, NULL);
break;
default: {
char *v;
if ((v = calloc(1, value_length + 1)) == NULL) {
ipp_set_status(message, PAPI_TEMPORARY_ERROR,
"calloc(): failed\n");
return (PAPI_TEMPORARY_ERROR);
}
if (iread(fd, v, value_length) != value_length) {
ipp_set_status(message, PAPI_BAD_REQUEST,
"bad read: other\n");
return (PAPI_BAD_REQUEST);
}
papiAttributeListAddString(&attributes,
PAPI_ATTR_APPEND, name, v);
}
break;
}
}
if (attributes != NULL) {
char name[32];
(void) ipp_tag_string(*type, name, sizeof (name));
papiAttributeListAddCollection(message, PAPI_ATTR_APPEND, name,
attributes);
}
*type = value_tag;
return (PAPI_OK);
}
static papi_status_t
ipp_read_header(ipp_reader_t iread, void *fd, papi_attribute_t ***message,
char type)
{
char *attr_name = "status-code"; /* default to a response */
char buf[8];
int8_t c;
uint16_t s;
int32_t i;
if ((iread == NULL) || (fd == NULL) || (message == NULL))
return (PAPI_BAD_ARGUMENT);
/*
* Apache 1.X uses the buffer supplied to it's read call to read in
* the chunk size when chunking is used. This causes problems
* reading the header a piece at a time, because we don't have
* enough room to read in the chunk size prior to reading the
* chunk.
*/
if (iread(fd, buf, 8) != 8)
return (PAPI_BAD_REQUEST);
c = buf[0];
(void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
"version-major", c);
c = buf[1];
(void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
"version-minor", c);
memcpy(&s, &buf[2], 2);
s = (uint16_t)ntohs(s);
if (type == IPP_TYPE_REQUEST)
attr_name = "operation-id";
(void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
attr_name, s);
memcpy(&i, &buf[4], 4);
i = (uint32_t)ntohl(i);
(void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
"request-id", i);
return (PAPI_OK);
}
static papi_status_t
ipp_read_attribute_groups(ipp_reader_t iread, void *fd,
papi_attribute_t ***message)
{
papi_status_t result = PAPI_OK;
int8_t tag;
/* start reading the attribute groups */
if (iread(fd, &tag, 1) != 1) /* prime the pump */
return (PAPI_BAD_REQUEST);
while ((tag != DTAG_END_OF_ATTRIBUTES) && (result == PAPI_OK)) {
result = ipp_read_attribute_group(iread, fd, &tag, message);
}
return (result);
}
papi_status_t
ipp_read_message(ipp_reader_t iread, void *fd, papi_attribute_t ***message,
char type)
{
papi_status_t result = PAPI_OK;
if ((iread == NULL) || (fd == NULL) || (message == NULL))
return (PAPI_BAD_ARGUMENT);
result = ipp_read_header(iread, fd, message, type);
if (result == PAPI_OK)
result = ipp_read_attribute_groups(iread, fd, message);
return (result);
}