1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 *
26 */
27
28 /* $Id: read.c 146 2006-03-24 00:26:54Z njacobs $ */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <alloca.h>
35 #include <string.h>
36 #include <stdarg.h>
37 #include <sys/types.h>
38 #include <netinet/in.h>
39 #include <inttypes.h>
40
41 #include <papi.h>
42 #include <ipp.h>
43
44
45 #define _ipp_tag_string(id) ipp_tag_string((id), buf, sizeof (buf))
46
47 static papi_status_t
read_name_with_language(ipp_reader_t iread,void * fd,papi_attribute_t *** message)48 read_name_with_language(ipp_reader_t iread, void *fd,
49 papi_attribute_t ***message)
50 {
51 char *string;
52 uint16_t size;
53
54 /* read the language */
55 if (iread(fd, &size, 2) != 2) {
56 ipp_set_status(message, PAPI_BAD_REQUEST,
57 "read failed: lang len\n");
58 return (PAPI_BAD_REQUEST);
59 }
60 size = (uint16_t)ntohs(size);
61
62 if ((string = alloca(size + 1)) == NULL) {
63 ipp_set_status(message, PAPI_TEMPORARY_ERROR,
64 "Memory allocation failed");
65 return (PAPI_TEMPORARY_ERROR);
66 }
67 if (iread(fd, string, size) != size) {
68 ipp_set_status(message, PAPI_BAD_REQUEST,
69 "read failed: lang\n");
70 return (PAPI_BAD_REQUEST);
71 }
72
73 /* read the text */
74 if (iread(fd, &size, 2) != 2) {
75 ipp_set_status(message, PAPI_BAD_REQUEST,
76 "read failed: text len\n");
77 return (PAPI_BAD_REQUEST);
78 }
79 size = (uint16_t)ntohs(size);
80
81 if ((string = alloca(size + 1)) == NULL) {
82 ipp_set_status(message, PAPI_TEMPORARY_ERROR,
83 "Memory allocation failed");
84 return (PAPI_TEMPORARY_ERROR);
85 }
86 if (iread(fd, string, size) != size) {
87 ipp_set_status(message, PAPI_BAD_REQUEST,
88 "read failed: text\n");
89 return (PAPI_BAD_REQUEST);
90 }
91
92 return (PAPI_OK);
93 }
94
95
96 static struct {
97 int8_t ipp_type;
98 int8_t size;
99 } type_info[] = {
100 { VTAG_INTEGER, 4 },
101 { VTAG_ENUM, 4 },
102 { VTAG_BOOLEAN, 1 },
103 { VTAG_RANGE_OF_INTEGER, 8 },
104 { VTAG_RESOLUTION, 9 },
105 { VTAG_DATE_TIME, 11 },
106 { DTAG_MIN, 0 }
107 };
108
109 /* verify that the IPP type and size are compatible */
110 static int
validate_length(int8_t type,int8_t size)111 validate_length(int8_t type, int8_t size)
112 {
113 int i;
114
115 for (i = 0; type_info[i].ipp_type != DTAG_MIN; i++)
116 if (type_info[i].ipp_type == type)
117 return ((type_info[i].size == size) ? 0 : -1);
118 return (0);
119 }
120
121 /* convert tyep IPP type to a type that is marginally compatible */
122 static int8_t
base_type(int8_t i)123 base_type(int8_t i)
124 {
125 switch (i) {
126 case VTAG_ENUM:
127 case VTAG_INTEGER:
128 return (VTAG_INTEGER);
129 case VTAG_URI:
130 case VTAG_OCTET_STRING:
131 case VTAG_TEXT_WITHOUT_LANGUAGE:
132 case VTAG_URI_SCHEME:
133 case VTAG_CHARSET:
134 case VTAG_NATURAL_LANGUAGE:
135 case VTAG_MIME_MEDIA_TYPE:
136 case VTAG_NAME_WITHOUT_LANGUAGE:
137 case VTAG_KEYWORD:
138 return (VTAG_TEXT_WITHOUT_LANGUAGE);
139 case VTAG_BOOLEAN:
140 case VTAG_RANGE_OF_INTEGER:
141 case VTAG_DATE_TIME:
142 case VTAG_RESOLUTION:
143 default:
144 return (i);
145 }
146 }
147
148 /* verify that the IPP type is correct for the named attribute */
149 static papi_status_t
validate_type(char * name,int8_t type)150 validate_type(char *name, int8_t type)
151 {
152 int8_t t = name_to_ipp_type(name);
153
154 if (t == 0) /* The attribute is not defined in the RFC */
155 return (PAPI_NOT_FOUND);
156 else if (t == type) /* The supplied type matched the RFC type */
157 return (PAPI_OK);
158 else { /* The supplied type doesn't match the RFC */
159 if (base_type(t) == base_type(type))
160 return (PAPI_OK);
161
162 return (PAPI_CONFLICT);
163 }
164 }
165
166 /* verify that the IPP value is within specification for the named attribute */
167 static int
validate_value(papi_attribute_t *** message,char * name,int8_t type,...)168 validate_value(papi_attribute_t ***message, char *name, int8_t type, ...)
169 {
170 #define within(a, b, c) ((b >= a) && (b <= c))
171 va_list ap;
172 int rc = -1;
173 int min = min_val_len(type, name),
174 max = max_val_len(type, name);
175 char buf[64]; /* For _ipp_<...>_string() */
176
177 va_start(ap, type);
178 switch (type) {
179 case VTAG_ENUM:
180 case VTAG_INTEGER: {
181 int32_t i = (int32_t)va_arg(ap, int32_t);
182
183 if (within(min, i, max))
184 rc = 0;
185 else
186 ipp_set_status(message, PAPI_BAD_ARGUMENT,
187 "%s(%s): %d: out of range (%d - %d)", name,
188 _ipp_tag_string(type), i, min, max);
189 }
190 break;
191 case VTAG_BOOLEAN: {
192 int8_t v = (int8_t)va_arg(ap, int);
193
194 if (within(0, v, 1))
195 rc = 0;
196 else
197 ipp_set_status(message, PAPI_BAD_ARGUMENT,
198 "%s(%s): %d: out of range (0 - 1)", name,
199 _ipp_tag_string(type), v);
200 }
201 break;
202 case VTAG_RANGE_OF_INTEGER: {
203 int32_t lower = (int32_t)va_arg(ap, int32_t);
204 int32_t upper = (int32_t)va_arg(ap, int32_t);
205
206 if (within(min, lower, max) &&
207 within(min, upper, max))
208 rc = 0;
209 else
210 ipp_set_status(message, PAPI_BAD_ARGUMENT,
211 "%s(%s): %d - %d: out of range (%d - %d)", name,
212 _ipp_tag_string(type), lower, upper, min, max);
213 }
214 break;
215 case VTAG_URI:
216 case VTAG_OCTET_STRING:
217 case VTAG_TEXT_WITHOUT_LANGUAGE:
218 case VTAG_URI_SCHEME:
219 case VTAG_CHARSET:
220 case VTAG_NATURAL_LANGUAGE:
221 case VTAG_MIME_MEDIA_TYPE:
222 case VTAG_NAME_WITHOUT_LANGUAGE: {
223 char *v = (char *)va_arg(ap, char *);
224
225 if (strlen(v) < max)
226 rc = 0;
227 else
228 ipp_set_status(message, PAPI_BAD_ARGUMENT,
229 "%s(%s): %s: too long (max length: %d)", name,
230 _ipp_tag_string(type), v, max);
231 }
232 break;
233 case VTAG_KEYWORD: {
234 char *v = (char *)va_arg(ap, char *);
235
236 if (strlen(v) >= max)
237 ipp_set_status(message, PAPI_BAD_ARGUMENT,
238 "%s(%s): %s: too long (max length: %d)", name,
239 _ipp_tag_string(type), v, max);
240 else if (is_keyword(v) == 0)
241 ipp_set_status(message, PAPI_BAD_ARGUMENT,
242 "%s(%s): %s: invalid keyword", name,
243 _ipp_tag_string(type), v);
244 else
245 rc = 0;
246 }
247 break;
248 case VTAG_DATE_TIME:
249 case VTAG_RESOLUTION:
250 default:
251 rc = 0;
252 }
253 va_end(ap);
254
255 return (rc);
256 #undef within
257 }
258
259 /*
260 * read_attr_group() reads in enough of the message data to parse an entire
261 * attribute group. Since to determine that the group is finished you have to
262 * read the character that determines the type of the next group, this function
263 * must return that character, in order that our caller knows how to call us for
264 * the next group. Thus type is used both as an input parameter (the type of
265 * attribute group to read in) and an output parameter (the type of the next
266 * attribute group).
267 */
268
269 static papi_status_t
ipp_read_attribute_group(ipp_reader_t iread,void * fd,int8_t * type,papi_attribute_t *** message)270 ipp_read_attribute_group(ipp_reader_t iread, void *fd, int8_t *type,
271 papi_attribute_t ***message)
272 {
273 int8_t value_tag;
274 uint16_t name_length, value_length;
275 papi_attribute_t **attributes = NULL;
276 char *name = NULL;
277 int i;
278 char buf[64]; /* For _ipp_<...>_string() */
279
280 /*
281 * RFC2910 3.3 says we need to handle `An expected but missing
282 * "begin-attribute-group-tag" field. How?
283 */
284 if (*type > DTAG_MAX) {
285 /* Scream bloody murder, or assign a new type? */
286 ipp_set_status(message, PAPI_BAD_REQUEST,
287 "Bad attribute group tag 0x%.2hx (%s)",
288 *type, _ipp_tag_string(*type));
289 return (PAPI_BAD_REQUEST);
290 }
291
292 /* This loops through *values* not *attributes*! */
293 for (i = 0; ; i++) {
294 papi_status_t valid = PAPI_OK;
295 if (iread(fd, &value_tag, 1) != 1) {
296 ipp_set_status(message, PAPI_BAD_REQUEST,
297 "bad read: value tag\n");
298 return (PAPI_BAD_REQUEST);
299 }
300 /* are we done with this group ? */
301 if (value_tag <= DTAG_MAX)
302 break;
303
304 if (iread(fd, &name_length, 2) != 2) {
305 ipp_set_status(message, PAPI_BAD_REQUEST,
306 "bad read: name length\n");
307 return (PAPI_BAD_REQUEST);
308 }
309 name_length = (uint16_t)ntohs(name_length);
310
311 /* Not just another value for the previous attribute */
312 if (name_length != 0) {
313 if ((name = alloca(name_length + 1)) == NULL) {
314 ipp_set_status(message, PAPI_TEMPORARY_ERROR,
315 "alloca(): failed\n");
316 return (PAPI_TEMPORARY_ERROR);
317 }
318 (void) memset(name, 0, name_length + 1);
319
320 if (iread(fd, name, name_length) != name_length) {
321 ipp_set_status(message, PAPI_BAD_REQUEST,
322 "bad read: name\n");
323 return (PAPI_BAD_REQUEST);
324 }
325 }
326
327 valid = validate_type(name, value_tag);
328 if ((valid != PAPI_OK) && (valid != PAPI_NOT_FOUND))
329 ipp_set_status(message, valid, "%s(%s): %s", name,
330 _ipp_tag_string(value_tag),
331 papiStatusString(valid));
332
333 if (iread(fd, &value_length, 2) != 2) {
334 ipp_set_status(message, PAPI_BAD_REQUEST,
335 "bad read: value length\n");
336 return (PAPI_BAD_REQUEST);
337 }
338 value_length = (uint16_t)ntohs(value_length);
339
340 if (validate_length(value_tag, value_length) < 0) {
341 ipp_set_status(message, PAPI_BAD_REQUEST,
342 "Bad value length (%d) for type %s",
343 value_length, _ipp_tag_string(value_tag));
344 return (PAPI_BAD_REQUEST);
345 }
346
347 switch (value_tag) {
348 case VTAG_INTEGER:
349 case VTAG_ENUM: {
350 int32_t v;
351
352 if (iread(fd, &v, value_length) != value_length) {
353 ipp_set_status(message, PAPI_BAD_REQUEST,
354 "bad read: int/enum\n");
355 return (PAPI_BAD_REQUEST);
356 }
357 v = (int32_t)ntohl(v);
358 (void) validate_value(message, name, value_tag, v);
359 papiAttributeListAddInteger(&attributes,
360 PAPI_ATTR_APPEND, name, v);
361
362 }
363 break;
364 case VTAG_BOOLEAN: {
365 int8_t v;
366
367 if (iread(fd, &v, value_length) != value_length) {
368 ipp_set_status(message, PAPI_BAD_REQUEST,
369 "bad read: boolean\n");
370 return (PAPI_BAD_REQUEST);
371 }
372 (void) validate_value(message, name, value_tag, v);
373 papiAttributeListAddBoolean(&attributes,
374 PAPI_ATTR_APPEND, name, v);
375 }
376 break;
377 case VTAG_RANGE_OF_INTEGER: {
378 int32_t min, max;
379
380 if (iread(fd, &min, 4) != 4) {
381 ipp_set_status(message, PAPI_BAD_REQUEST,
382 "bad read: min\n");
383 return (PAPI_BAD_REQUEST);
384 }
385 if (iread(fd, &max, 4) != 4) {
386 ipp_set_status(message, PAPI_BAD_REQUEST,
387 "bad read: max\n");
388 return (PAPI_BAD_REQUEST);
389 }
390 min = (int32_t)ntohl(min);
391 max = (int32_t)ntohl(max);
392 (void) validate_value(message, name, value_tag,
393 min, max);
394 papiAttributeListAddRange(&attributes, PAPI_ATTR_APPEND,
395 name, min, max);
396 }
397 break;
398 case VTAG_RESOLUTION: {
399 int32_t x, y;
400 int8_t units;
401
402 if (iread(fd, &x, 4) != 4) {
403 ipp_set_status(message, PAPI_BAD_REQUEST,
404 "bad read: x\n");
405 return (PAPI_BAD_REQUEST);
406 }
407 if (iread(fd, &y, 4) != 4) {
408 ipp_set_status(message, PAPI_BAD_REQUEST,
409 "bad read: y\n");
410 return (PAPI_BAD_REQUEST);
411 }
412 if (iread(fd, &units, 1) != 1) {
413 ipp_set_status(message, PAPI_BAD_REQUEST,
414 "bad read: units\n");
415 return (PAPI_BAD_REQUEST);
416 }
417 x = (int32_t)ntohl(x);
418 y = (int32_t)ntohl(y);
419 papiAttributeListAddResolution(&attributes,
420 PAPI_ATTR_APPEND, name, x, y,
421 (papi_resolution_unit_t)units);
422 }
423 break;
424 case VTAG_DATE_TIME: {
425 struct tm tm;
426 time_t v;
427 int8_t c;
428 uint16_t s;
429
430 (void) memset(&tm, 0, sizeof (tm));
431 if (iread(fd, &s, 2) != 2) {
432 ipp_set_status(message, PAPI_BAD_REQUEST,
433 "bad read: year\n");
434 return (PAPI_BAD_REQUEST);
435 }
436 tm.tm_year = (uint16_t)ntohs(s) - 1900;
437 if (iread(fd, &c, 1) != 1) {
438 ipp_set_status(message, PAPI_BAD_REQUEST,
439 "bad read: month\n");
440 return (PAPI_BAD_REQUEST);
441 }
442 tm.tm_mon = c - 1;
443 if (iread(fd, &c, 1) != 1) {
444 ipp_set_status(message, PAPI_BAD_REQUEST,
445 "bad read: day\n");
446 return (PAPI_BAD_REQUEST);
447 }
448 tm.tm_mday = c;
449 if (iread(fd, &c, 1) != 1) {
450 ipp_set_status(message, PAPI_BAD_REQUEST,
451 "bad read: hour\n");
452 return (PAPI_BAD_REQUEST);
453 }
454 tm.tm_hour = c;
455 if (iread(fd, &c, 1) != 1) {
456 ipp_set_status(message, PAPI_BAD_REQUEST,
457 "bad read: minutes\n");
458 return (PAPI_BAD_REQUEST);
459 }
460 tm.tm_min = c;
461 if (iread(fd, &c, 1) != 1) {
462 ipp_set_status(message, PAPI_BAD_REQUEST,
463 "bad read: seconds\n");
464 return (PAPI_BAD_REQUEST);
465 }
466 tm.tm_sec = c;
467 if (iread(fd, &c, 1) != 1) {
468 ipp_set_status(message, PAPI_BAD_REQUEST,
469 "bad read: decisec\n");
470 return (PAPI_BAD_REQUEST);
471 }
472 /* tm.deciseconds = c; */
473 if (iread(fd, &c, 1) != 1) {
474 ipp_set_status(message, PAPI_BAD_REQUEST,
475 "bad read: utc_dir\n");
476 return (PAPI_BAD_REQUEST);
477 }
478 /* tm.utc_dir = c; */
479 if (iread(fd, &c, 1) != 1) {
480 ipp_set_status(message, PAPI_BAD_REQUEST,
481 "bad read: utc_hour\n");
482 return (PAPI_BAD_REQUEST);
483 }
484 /* tm.utc_hours = c; */
485 if (iread(fd, &c, 1) != 1) {
486 ipp_set_status(message, PAPI_BAD_REQUEST,
487 "bad read: utc_min\n");
488 return (PAPI_BAD_REQUEST);
489 }
490 /* tm.utc_minutes = c; */
491
492 v = mktime(&tm);
493
494 (void) validate_value(message, name, value_tag, v);
495 papiAttributeListAddDatetime(&attributes,
496 PAPI_ATTR_APPEND, name, v);
497 }
498 break;
499 case VTAG_NAME_WITH_LANGUAGE:
500 case VTAG_TEXT_WITH_LANGUAGE:
501 /*
502 * we are dropping this because we don't support
503 * name with language at this time.
504 */
505 (void) read_name_with_language(iread, fd, message);
506 break;
507 case VTAG_NAME_WITHOUT_LANGUAGE:
508 case VTAG_TEXT_WITHOUT_LANGUAGE:
509 case VTAG_URI:
510 case VTAG_KEYWORD:
511 case VTAG_CHARSET: {
512 char *v;
513
514 if ((v = calloc(1, value_length + 1)) == NULL) {
515 ipp_set_status(message, PAPI_TEMPORARY_ERROR,
516 "calloc(): failed\n");
517 return (PAPI_TEMPORARY_ERROR);
518 }
519 #ifdef NOTDEF
520 if (iread(fd, v, value_length) != value_length) {
521 ipp_set_status(message, PAPI_BAD_REQUEST,
522 "bad read: stringy\n");
523 return (PAPI_BAD_REQUEST);
524 }
525 #else
526 {
527 int rc, i = value_length;
528 char *p = v;
529
530 while ((rc = iread(fd, p, i)) != i) {
531 if (rc <= 0) {
532 ipp_set_status(message,
533 PAPI_BAD_REQUEST,
534 "bad read: stringy\n");
535 return (PAPI_BAD_REQUEST);
536 }
537 i -= rc;
538 p += rc;
539 }
540 }
541 #endif
542 (void) validate_value(message, name, value_tag, v);
543 papiAttributeListAddString(&attributes,
544 PAPI_ATTR_APPEND, name, v);
545 }
546 break;
547 case VTAG_UNKNOWN:
548 case VTAG_NOVALUE:
549 case VTAG_UNSUPPORTED:
550 papiAttributeListAddValue(&attributes, PAPI_ATTR_EXCL,
551 name, PAPI_COLLECTION, NULL);
552 break;
553 default: {
554 char *v;
555
556 if ((v = calloc(1, value_length + 1)) == NULL) {
557 ipp_set_status(message, PAPI_TEMPORARY_ERROR,
558 "calloc(): failed\n");
559 return (PAPI_TEMPORARY_ERROR);
560 }
561 if (iread(fd, v, value_length) != value_length) {
562 ipp_set_status(message, PAPI_BAD_REQUEST,
563 "bad read: other\n");
564 return (PAPI_BAD_REQUEST);
565 }
566 papiAttributeListAddString(&attributes,
567 PAPI_ATTR_APPEND, name, v);
568 }
569 break;
570 }
571 }
572
573 if (attributes != NULL) {
574 char name[32];
575
576 (void) ipp_tag_string(*type, name, sizeof (name));
577 papiAttributeListAddCollection(message, PAPI_ATTR_APPEND, name,
578 attributes);
579 }
580
581 *type = value_tag;
582
583 return (PAPI_OK);
584 }
585
586
587 static papi_status_t
ipp_read_header(ipp_reader_t iread,void * fd,papi_attribute_t *** message,char type)588 ipp_read_header(ipp_reader_t iread, void *fd, papi_attribute_t ***message,
589 char type)
590 {
591 char *attr_name = "status-code"; /* default to a response */
592 char buf[8];
593 int8_t c;
594 uint16_t s;
595 int32_t i;
596
597 if ((iread == NULL) || (fd == NULL) || (message == NULL))
598 return (PAPI_BAD_ARGUMENT);
599
600 /*
601 * Apache 1.X uses the buffer supplied to it's read call to read in
602 * the chunk size when chunking is used. This causes problems
603 * reading the header a piece at a time, because we don't have
604 * enough room to read in the chunk size prior to reading the
605 * chunk.
606 */
607
608 if (iread(fd, buf, 8) != 8)
609 return (PAPI_BAD_REQUEST);
610
611 c = buf[0];
612 (void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
613 "version-major", c);
614
615 c = buf[1];
616 (void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
617 "version-minor", c);
618
619 memcpy(&s, &buf[2], 2);
620 s = (uint16_t)ntohs(s);
621 if (type == IPP_TYPE_REQUEST)
622 attr_name = "operation-id";
623 (void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
624 attr_name, s);
625
626 memcpy(&i, &buf[4], 4);
627 i = (uint32_t)ntohl(i);
628 (void) papiAttributeListAddInteger(message, PAPI_ATTR_REPLACE,
629 "request-id", i);
630
631 return (PAPI_OK);
632 }
633
634 static papi_status_t
ipp_read_attribute_groups(ipp_reader_t iread,void * fd,papi_attribute_t *** message)635 ipp_read_attribute_groups(ipp_reader_t iread, void *fd,
636 papi_attribute_t ***message)
637 {
638 papi_status_t result = PAPI_OK;
639 int8_t tag;
640
641 /* start reading the attribute groups */
642 if (iread(fd, &tag, 1) != 1) /* prime the pump */
643 return (PAPI_BAD_REQUEST);
644
645 while ((tag != DTAG_END_OF_ATTRIBUTES) && (result == PAPI_OK)) {
646 result = ipp_read_attribute_group(iread, fd, &tag, message);
647 }
648
649 return (result);
650 }
651
652 papi_status_t
ipp_read_message(ipp_reader_t iread,void * fd,papi_attribute_t *** message,char type)653 ipp_read_message(ipp_reader_t iread, void *fd, papi_attribute_t ***message,
654 char type)
655 {
656 papi_status_t result = PAPI_OK;
657
658 if ((iread == NULL) || (fd == NULL) || (message == NULL))
659 return (PAPI_BAD_ARGUMENT);
660
661 result = ipp_read_header(iread, fd, message, type);
662 if (result == PAPI_OK)
663 result = ipp_read_attribute_groups(iread, fd, message);
664
665 return (result);
666 }
667