/*
 * 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);
}