]> git.ipfire.org Git - thirdparty/cups.git/blob - cups/ipp.c
projects / thirdparty / cups.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #4996 from psychomario/cupstestppdbof
[thirdparty/cups.git] / cups / ipp.c
1 /*
2 * Internet Printing Protocol functions for CUPS.
3 *
4 * Copyright 2007-2017 by Apple Inc.
5 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
6 *
7 * These coded instructions, statements, and computer programs are the
8 * property of Apple Inc. and are protected by Federal copyright
9 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
10 * which should have been included with this file. If this file is
11 * missing or damaged, see the license at "http://www.cups.org/".
12 *
13 * This file is subject to the Apple OS-Developed Software exception.
14 */
15
16 /*
17 * Include necessary headers...
18 */
19
20 #include "cups-private.h"
21 #include <regex.h>
22 #ifdef WIN32
23 # include <io.h>
24 #endif /* WIN32 */
25
26
27 /*
28 * Local functions...
29 */
30
31 static ipp_attribute_t *ipp_add_attr(ipp_t *ipp, const char *name,
32 ipp_tag_t group_tag, ipp_tag_t value_tag,
33 int num_values);
34 static void ipp_free_values(ipp_attribute_t *attr, int element,
35 int count);
36 static char *ipp_get_code(const char *locale, char *buffer,
37 size_t bufsize)
38 __attribute__((nonnull(1,2)));
39 static char *ipp_lang_code(const char *locale, char *buffer,
40 size_t bufsize)
41 __attribute__((nonnull(1,2)));
42 static size_t ipp_length(ipp_t *ipp, int collection);
43 static ssize_t ipp_read_http(http_t *http, ipp_uchar_t *buffer,
44 size_t length);
45 static ssize_t ipp_read_file(int *fd, ipp_uchar_t *buffer,
46 size_t length);
47 static void ipp_set_error(ipp_status_t status, const char *format,
48 ...);
49 static _ipp_value_t *ipp_set_value(ipp_t *ipp, ipp_attribute_t **attr,
50 int element);
51 static ssize_t ipp_write_file(int *fd, ipp_uchar_t *buffer,
52 size_t length);
53
54
55 /*
56 * '_cupsBufferGet()' - Get a read/write buffer.
57 */
58
59 char * /* O - Buffer */
60 _cupsBufferGet(size_t size) /* I - Size required */
61 {
62 _cups_buffer_t *buffer; /* Current buffer */
63 _cups_globals_t *cg = _cupsGlobals();
64 /* Global data */
65
66
67 for (buffer = cg->cups_buffers; buffer; buffer = buffer->next)
68 if (!buffer->used && buffer->size >= size)
69 break;
70
71 if (!buffer)
72 {
73 if ((buffer = malloc(sizeof(_cups_buffer_t) + size - 1)) == NULL)
74 return (NULL);
75
76 buffer->next = cg->cups_buffers;
77 buffer->size = size;
78 cg->cups_buffers = buffer;
79 }
80
81 buffer->used = 1;
82
83 return (buffer->d);
84 }
85
86
87 /*
88 * '_cupsBufferRelease()' - Release a read/write buffer.
89 */
90
91 void
92 _cupsBufferRelease(char *b) /* I - Buffer to release */
93 {
94 _cups_buffer_t *buffer; /* Buffer */
95
96
97 /*
98 * Mark this buffer as unused...
99 */
100
101 buffer = (_cups_buffer_t *)(b - offsetof(_cups_buffer_t, d));
102 buffer->used = 0;
103 }
104
105
106 /*
107 * 'ippAddBoolean()' - Add a boolean attribute to an IPP message.
108 *
109 * The @code ipp@ parameter refers to an IPP message previously created using
110 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
111 *
112 * The @code group@ parameter specifies the IPP attribute group tag: none
113 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
114 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
115 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
116 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
117 */
118
119 ipp_attribute_t * /* O - New attribute */
120 ippAddBoolean(ipp_t *ipp, /* I - IPP message */
121 ipp_tag_t group, /* I - IPP group */
122 const char *name, /* I - Name of attribute */
123 char value) /* I - Value of attribute */
124 {
125 ipp_attribute_t *attr; /* New attribute */
126
127
128 DEBUG_printf(("ippAddBoolean(ipp=%p, group=%02x(%s), name=\"%s\", value=%d)", (void *)ipp, group, ippTagString(group), name, value));
129
130 /*
131 * Range check input...
132 */
133
134 if (!ipp || !name || group < IPP_TAG_ZERO ||
135 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
136 return (NULL);
137
138 /*
139 * Create the attribute...
140 */
141
142 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_BOOLEAN, 1)) == NULL)
143 return (NULL);
144
145 attr->values[0].boolean = value;
146
147 return (attr);
148 }
149
150
151 /*
152 * 'ippAddBooleans()' - Add an array of boolean values.
153 *
154 * The @code ipp@ parameter refers to an IPP message previously created using
155 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
156 *
157 * The @code group@ parameter specifies the IPP attribute group tag: none
158 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
159 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
160 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
161 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
162 */
163
164 ipp_attribute_t * /* O - New attribute */
165 ippAddBooleans(ipp_t *ipp, /* I - IPP message */
166 ipp_tag_t group, /* I - IPP group */
167 const char *name, /* I - Name of attribute */
168 int num_values, /* I - Number of values */
169 const char *values) /* I - Values */
170 {
171 int i; /* Looping var */
172 ipp_attribute_t *attr; /* New attribute */
173 _ipp_value_t *value; /* Current value */
174
175
176 DEBUG_printf(("ippAddBooleans(ipp=%p, group=%02x(%s), name=\"%s\", num_values=%d, values=%p)", (void *)ipp, group, ippTagString(group), name, num_values, (void *)values));
177
178 /*
179 * Range check input...
180 */
181
182 if (!ipp || !name || group < IPP_TAG_ZERO ||
183 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
184 num_values < 1)
185 return (NULL);
186
187 /*
188 * Create the attribute...
189 */
190
191 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_BOOLEAN, num_values)) == NULL)
192 return (NULL);
193
194 if (values)
195 {
196 for (i = num_values, value = attr->values;
197 i > 0;
198 i --, value ++)
199 value->boolean = *values++;
200 }
201
202 return (attr);
203 }
204
205
206 /*
207 * 'ippAddCollection()' - Add a collection value.
208 *
209 * The @code ipp@ parameter refers to an IPP message previously created using
210 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
211 *
212 * The @code group@ parameter specifies the IPP attribute group tag: none
213 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
214 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
215 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
216 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
217 *
218 * @since CUPS 1.1.19/macOS 10.3@
219 */
220
221 ipp_attribute_t * /* O - New attribute */
222 ippAddCollection(ipp_t *ipp, /* I - IPP message */
223 ipp_tag_t group, /* I - IPP group */
224 const char *name, /* I - Name of attribute */
225 ipp_t *value) /* I - Value */
226 {
227 ipp_attribute_t *attr; /* New attribute */
228
229
230 DEBUG_printf(("ippAddCollection(ipp=%p, group=%02x(%s), name=\"%s\", value=%p)", (void *)ipp, group, ippTagString(group), name, (void *)value));
231
232 /*
233 * Range check input...
234 */
235
236 if (!ipp || !name || group < IPP_TAG_ZERO ||
237 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
238 return (NULL);
239
240 /*
241 * Create the attribute...
242 */
243
244 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_BEGIN_COLLECTION, 1)) == NULL)
245 return (NULL);
246
247 attr->values[0].collection = value;
248
249 if (value)
250 value->use ++;
251
252 return (attr);
253 }
254
255
256 /*
257 * 'ippAddCollections()' - Add an array of collection values.
258 *
259 * The @code ipp@ parameter refers to an IPP message previously created using
260 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
261 *
262 * The @code group@ parameter specifies the IPP attribute group tag: none
263 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
264 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
265 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
266 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
267 *
268 * @since CUPS 1.1.19/macOS 10.3@
269 */
270
271 ipp_attribute_t * /* O - New attribute */
272 ippAddCollections(
273 ipp_t *ipp, /* I - IPP message */
274 ipp_tag_t group, /* I - IPP group */
275 const char *name, /* I - Name of attribute */
276 int num_values, /* I - Number of values */
277 const ipp_t **values) /* I - Values */
278 {
279 int i; /* Looping var */
280 ipp_attribute_t *attr; /* New attribute */
281 _ipp_value_t *value; /* Current value */
282
283
284 DEBUG_printf(("ippAddCollections(ipp=%p, group=%02x(%s), name=\"%s\", num_values=%d, values=%p)", (void *)ipp, group, ippTagString(group), name, num_values, (void *)values));
285
286 /*
287 * Range check input...
288 */
289
290 if (!ipp || !name || group < IPP_TAG_ZERO ||
291 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
292 num_values < 1)
293 return (NULL);
294
295 /*
296 * Create the attribute...
297 */
298
299 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_BEGIN_COLLECTION,
300 num_values)) == NULL)
301 return (NULL);
302
303 if (values)
304 {
305 for (i = num_values, value = attr->values;
306 i > 0;
307 i --, value ++)
308 {
309 value->collection = (ipp_t *)*values++;
310 value->collection->use ++;
311 }
312 }
313
314 return (attr);
315 }
316
317
318 /*
319 * 'ippAddDate()' - Add a dateTime attribute to an IPP message.
320 *
321 * The @code ipp@ parameter refers to an IPP message previously created using
322 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
323 *
324 * The @code group@ parameter specifies the IPP attribute group tag: none
325 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
326 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
327 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
328 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
329 */
330
331 ipp_attribute_t * /* O - New attribute */
332 ippAddDate(ipp_t *ipp, /* I - IPP message */
333 ipp_tag_t group, /* I - IPP group */
334 const char *name, /* I - Name of attribute */
335 const ipp_uchar_t *value) /* I - Value */
336 {
337 ipp_attribute_t *attr; /* New attribute */
338
339
340 DEBUG_printf(("ippAddDate(ipp=%p, group=%02x(%s), name=\"%s\", value=%p)", (void *)ipp, group, ippTagString(group), name, (void *)value));
341
342 /*
343 * Range check input...
344 */
345
346 if (!ipp || !name || !value || group < IPP_TAG_ZERO ||
347 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
348 return (NULL);
349
350 /*
351 * Create the attribute...
352 */
353
354 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_DATE, 1)) == NULL)
355 return (NULL);
356
357 memcpy(attr->values[0].date, value, 11);
358
359 return (attr);
360 }
361
362
363 /*
364 * 'ippAddInteger()' - Add a integer attribute to an IPP message.
365 *
366 * The @code ipp@ parameter refers to an IPP message previously created using
367 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
368 *
369 * The @code group@ parameter specifies the IPP attribute group tag: none
370 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
371 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
372 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
373 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
374 *
375 * Supported values include enum (@code IPP_TAG_ENUM@) and integer
376 * (@code IPP_TAG_INTEGER@).
377 */
378
379 ipp_attribute_t * /* O - New attribute */
380 ippAddInteger(ipp_t *ipp, /* I - IPP message */
381 ipp_tag_t group, /* I - IPP group */
382 ipp_tag_t value_tag, /* I - Type of attribute */
383 const char *name, /* I - Name of attribute */
384 int value) /* I - Value of attribute */
385 {
386 ipp_attribute_t *attr; /* New attribute */
387
388
389 DEBUG_printf(("ippAddInteger(ipp=%p, group=%02x(%s), type=%02x(%s), name=\"%s\", value=%d)", (void *)ipp, group, ippTagString(group), value_tag, ippTagString(value_tag), name, value));
390
391 value_tag &= IPP_TAG_CUPS_MASK;
392
393 /*
394 * Special-case for legacy usage: map out-of-band attributes to new ippAddOutOfBand
395 * function...
396 */
397
398 if (value_tag >= IPP_TAG_UNSUPPORTED_VALUE && value_tag <= IPP_TAG_ADMINDEFINE)
399 return (ippAddOutOfBand(ipp, group, value_tag, name));
400
401 /*
402 * Range check input...
403 */
404
405 #if 0
406 if (!ipp || !name || group < IPP_TAG_ZERO ||
407 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
408 (value_tag != IPP_TAG_INTEGER && value_tag != IPP_TAG_ENUM))
409 return (NULL);
410 #else
411 if (!ipp || !name || group < IPP_TAG_ZERO ||
412 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
413 return (NULL);
414 #endif /* 0 */
415
416 /*
417 * Create the attribute...
418 */
419
420 if ((attr = ipp_add_attr(ipp, name, group, value_tag, 1)) == NULL)
421 return (NULL);
422
423 attr->values[0].integer = value;
424
425 return (attr);
426 }
427
428
429 /*
430 * 'ippAddIntegers()' - Add an array of integer values.
431 *
432 * The @code ipp@ parameter refers to an IPP message previously created using
433 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
434 *
435 * The @code group@ parameter specifies the IPP attribute group tag: none
436 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
437 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
438 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
439 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
440 *
441 * Supported values include enum (@code IPP_TAG_ENUM@) and integer
442 * (@code IPP_TAG_INTEGER@).
443 */
444
445 ipp_attribute_t * /* O - New attribute */
446 ippAddIntegers(ipp_t *ipp, /* I - IPP message */
447 ipp_tag_t group, /* I - IPP group */
448 ipp_tag_t value_tag, /* I - Type of attribute */
449 const char *name, /* I - Name of attribute */
450 int num_values, /* I - Number of values */
451 const int *values) /* I - Values */
452 {
453 int i; /* Looping var */
454 ipp_attribute_t *attr; /* New attribute */
455 _ipp_value_t *value; /* Current value */
456
457
458 DEBUG_printf(("ippAddIntegers(ipp=%p, group=%02x(%s), type=%02x(%s), name=\"%s\", num_values=%d, values=%p)", (void *)ipp, group, ippTagString(group), value_tag, ippTagString(value_tag), name, num_values, (void *)values));
459
460 value_tag &= IPP_TAG_CUPS_MASK;
461
462 /*
463 * Range check input...
464 */
465
466 #if 0
467 if (!ipp || !name || group < IPP_TAG_ZERO ||
468 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
469 (value_tag != IPP_TAG_INTEGER && value_tag != IPP_TAG_ENUM) ||
470 num_values < 1)
471 return (NULL);
472 #else
473 if (!ipp || !name || group < IPP_TAG_ZERO ||
474 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
475 num_values < 1)
476 return (NULL);
477 #endif /* 0 */
478
479 /*
480 * Create the attribute...
481 */
482
483 if ((attr = ipp_add_attr(ipp, name, group, value_tag, num_values)) == NULL)
484 return (NULL);
485
486 if (values)
487 {
488 for (i = num_values, value = attr->values;
489 i > 0;
490 i --, value ++)
491 value->integer = *values++;
492 }
493
494 return (attr);
495 }
496
497
498 /*
499 * 'ippAddOctetString()' - Add an octetString value to an IPP message.
500 *
501 * The @code ipp@ parameter refers to an IPP message previously created using
502 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
503 *
504 * The @code group@ parameter specifies the IPP attribute group tag: none
505 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
506 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
507 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
508 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
509 *
510 * @since CUPS 1.2/macOS 10.5@
511 */
512
513 ipp_attribute_t * /* O - New attribute */
514 ippAddOctetString(ipp_t *ipp, /* I - IPP message */
515 ipp_tag_t group, /* I - IPP group */
516 const char *name, /* I - Name of attribute */
517 const void *data, /* I - octetString data */
518 int datalen) /* I - Length of data in bytes */
519 {
520 ipp_attribute_t *attr; /* New attribute */
521
522
523 if (!ipp || !name || group < IPP_TAG_ZERO ||
524 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
525 datalen < 0 || datalen > IPP_MAX_LENGTH)
526 return (NULL);
527
528 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_STRING, 1)) == NULL)
529 return (NULL);
530
531 /*
532 * Initialize the attribute data...
533 */
534
535 attr->values[0].unknown.length = datalen;
536
537 if (data)
538 {
539 if ((attr->values[0].unknown.data = malloc((size_t)datalen)) == NULL)
540 {
541 ippDeleteAttribute(ipp, attr);
542 return (NULL);
543 }
544
545 memcpy(attr->values[0].unknown.data, data, (size_t)datalen);
546 }
547
548 /*
549 * Return the new attribute...
550 */
551
552 return (attr);
553 }
554
555
556 /*
557 * 'ippAddOutOfBand()' - Add an out-of-band value to an IPP message.
558 *
559 * The @code ipp@ parameter refers to an IPP message previously created using
560 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
561 *
562 * The @code group@ parameter specifies the IPP attribute group tag: none
563 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
564 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
565 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
566 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
567 *
568 * Supported out-of-band values include unsupported-value
569 * (@code IPP_TAG_UNSUPPORTED_VALUE@), default (@code IPP_TAG_DEFAULT@), unknown
570 * (@code IPP_TAG_UNKNOWN@), no-value (@code IPP_TAG_NOVALUE@), not-settable
571 * (@code IPP_TAG_NOTSETTABLE@), delete-attribute (@code IPP_TAG_DELETEATTR@), and
572 * admin-define (@code IPP_TAG_ADMINDEFINE@).
573 *
574 * @since CUPS 1.6/macOS 10.8@
575 */
576
577 ipp_attribute_t * /* O - New attribute */
578 ippAddOutOfBand(ipp_t *ipp, /* I - IPP message */
579 ipp_tag_t group, /* I - IPP group */
580 ipp_tag_t value_tag, /* I - Type of attribute */
581 const char *name) /* I - Name of attribute */
582 {
583 DEBUG_printf(("ippAddOutOfBand(ipp=%p, group=%02x(%s), value_tag=%02x(%s), name=\"%s\")", (void *)ipp, group, ippTagString(group), value_tag, ippTagString(value_tag), name));
584
585 value_tag &= IPP_TAG_CUPS_MASK;
586
587 /*
588 * Range check input...
589 */
590
591 if (!ipp || !name || group < IPP_TAG_ZERO ||
592 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
593 (value_tag != IPP_TAG_UNSUPPORTED_VALUE &&
594 value_tag != IPP_TAG_DEFAULT &&
595 value_tag != IPP_TAG_UNKNOWN &&
596 value_tag != IPP_TAG_NOVALUE &&
597 value_tag != IPP_TAG_NOTSETTABLE &&
598 value_tag != IPP_TAG_DELETEATTR &&
599 value_tag != IPP_TAG_ADMINDEFINE))
600 return (NULL);
601
602 /*
603 * Create the attribute...
604 */
605
606 return (ipp_add_attr(ipp, name, group, value_tag, 1));
607 }
608
609
610 /*
611 * 'ippAddRange()' - Add a range of values to an IPP message.
612 *
613 * The @code ipp@ parameter refers to an IPP message previously created using
614 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
615 *
616 * The @code group@ parameter specifies the IPP attribute group tag: none
617 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
618 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
619 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
620 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
621 *
622 * The @code lower@ parameter must be less than or equal to the @code upper@ parameter.
623 */
624
625 ipp_attribute_t * /* O - New attribute */
626 ippAddRange(ipp_t *ipp, /* I - IPP message */
627 ipp_tag_t group, /* I - IPP group */
628 const char *name, /* I - Name of attribute */
629 int lower, /* I - Lower value */
630 int upper) /* I - Upper value */
631 {
632 ipp_attribute_t *attr; /* New attribute */
633
634
635 DEBUG_printf(("ippAddRange(ipp=%p, group=%02x(%s), name=\"%s\", lower=%d, upper=%d)", (void *)ipp, group, ippTagString(group), name, lower, upper));
636
637 /*
638 * Range check input...
639 */
640
641 if (!ipp || !name || group < IPP_TAG_ZERO ||
642 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
643 return (NULL);
644
645 /*
646 * Create the attribute...
647 */
648
649 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_RANGE, 1)) == NULL)
650 return (NULL);
651
652 attr->values[0].range.lower = lower;
653 attr->values[0].range.upper = upper;
654
655 return (attr);
656 }
657
658
659 /*
660 * 'ippAddRanges()' - Add ranges of values to an IPP message.
661 *
662 * The @code ipp@ parameter refers to an IPP message previously created using
663 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
664 *
665 * The @code group@ parameter specifies the IPP attribute group tag: none
666 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
667 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
668 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
669 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
670 */
671
672 ipp_attribute_t * /* O - New attribute */
673 ippAddRanges(ipp_t *ipp, /* I - IPP message */
674 ipp_tag_t group, /* I - IPP group */
675 const char *name, /* I - Name of attribute */
676 int num_values, /* I - Number of values */
677 const int *lower, /* I - Lower values */
678 const int *upper) /* I - Upper values */
679 {
680 int i; /* Looping var */
681 ipp_attribute_t *attr; /* New attribute */
682 _ipp_value_t *value; /* Current value */
683
684
685 DEBUG_printf(("ippAddRanges(ipp=%p, group=%02x(%s), name=\"%s\", num_values=%d, lower=%p, upper=%p)", (void *)ipp, group, ippTagString(group), name, num_values, (void *)lower, (void *)upper));
686
687 /*
688 * Range check input...
689 */
690
691 if (!ipp || !name || group < IPP_TAG_ZERO ||
692 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
693 num_values < 1)
694 return (NULL);
695
696 /*
697 * Create the attribute...
698 */
699
700 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_RANGE, num_values)) == NULL)
701 return (NULL);
702
703 if (lower && upper)
704 {
705 for (i = num_values, value = attr->values;
706 i > 0;
707 i --, value ++)
708 {
709 value->range.lower = *lower++;
710 value->range.upper = *upper++;
711 }
712 }
713
714 return (attr);
715 }
716
717
718 /*
719 * 'ippAddResolution()' - Add a resolution value to an IPP message.
720 *
721 * The @code ipp@ parameter refers to an IPP message previously created using
722 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
723 *
724 * The @code group@ parameter specifies the IPP attribute group tag: none
725 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
726 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
727 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
728 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
729 */
730
731 ipp_attribute_t * /* O - New attribute */
732 ippAddResolution(ipp_t *ipp, /* I - IPP message */
733 ipp_tag_t group, /* I - IPP group */
734 const char *name, /* I - Name of attribute */
735 ipp_res_t units, /* I - Units for resolution */
736 int xres, /* I - X resolution */
737 int yres) /* I - Y resolution */
738 {
739 ipp_attribute_t *attr; /* New attribute */
740
741
742 DEBUG_printf(("ippAddResolution(ipp=%p, group=%02x(%s), name=\"%s\", units=%d, xres=%d, yres=%d)", (void *)ipp, group,
743 ippTagString(group), name, units, xres, yres));
744
745 /*
746 * Range check input...
747 */
748
749 if (!ipp || !name || group < IPP_TAG_ZERO ||
750 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
751 units < IPP_RES_PER_INCH || units > IPP_RES_PER_CM ||
752 xres < 0 || yres < 0)
753 return (NULL);
754
755 /*
756 * Create the attribute...
757 */
758
759 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_RESOLUTION, 1)) == NULL)
760 return (NULL);
761
762 attr->values[0].resolution.xres = xres;
763 attr->values[0].resolution.yres = yres;
764 attr->values[0].resolution.units = units;
765
766 return (attr);
767 }
768
769
770 /*
771 * 'ippAddResolutions()' - Add resolution values to an IPP message.
772 *
773 * The @code ipp@ parameter refers to an IPP message previously created using
774 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
775 *
776 * The @code group@ parameter specifies the IPP attribute group tag: none
777 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
778 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
779 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
780 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
781 */
782
783 ipp_attribute_t * /* O - New attribute */
784 ippAddResolutions(ipp_t *ipp, /* I - IPP message */
785 ipp_tag_t group, /* I - IPP group */
786 const char *name, /* I - Name of attribute */
787 int num_values,/* I - Number of values */
788 ipp_res_t units, /* I - Units for resolution */
789 const int *xres, /* I - X resolutions */
790 const int *yres) /* I - Y resolutions */
791 {
792 int i; /* Looping var */
793 ipp_attribute_t *attr; /* New attribute */
794 _ipp_value_t *value; /* Current value */
795
796
797 DEBUG_printf(("ippAddResolutions(ipp=%p, group=%02x(%s), name=\"%s\", num_value=%d, units=%d, xres=%p, yres=%p)", (void *)ipp, group, ippTagString(group), name, num_values, units, (void *)xres, (void *)yres));
798
799 /*
800 * Range check input...
801 */
802
803 if (!ipp || !name || group < IPP_TAG_ZERO ||
804 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
805 num_values < 1 ||
806 units < IPP_RES_PER_INCH || units > IPP_RES_PER_CM)
807 return (NULL);
808
809 /*
810 * Create the attribute...
811 */
812
813 if ((attr = ipp_add_attr(ipp, name, group, IPP_TAG_RESOLUTION, num_values)) == NULL)
814 return (NULL);
815
816 if (xres && yres)
817 {
818 for (i = num_values, value = attr->values;
819 i > 0;
820 i --, value ++)
821 {
822 value->resolution.xres = *xres++;
823 value->resolution.yres = *yres++;
824 value->resolution.units = units;
825 }
826 }
827
828 return (attr);
829 }
830
831
832 /*
833 * 'ippAddSeparator()' - Add a group separator to an IPP message.
834 *
835 * The @code ipp@ parameter refers to an IPP message previously created using
836 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
837 */
838
839 ipp_attribute_t * /* O - New attribute */
840 ippAddSeparator(ipp_t *ipp) /* I - IPP message */
841 {
842 DEBUG_printf(("ippAddSeparator(ipp=%p)", (void *)ipp));
843
844 /*
845 * Range check input...
846 */
847
848 if (!ipp)
849 return (NULL);
850
851 /*
852 * Create the attribute...
853 */
854
855 return (ipp_add_attr(ipp, NULL, IPP_TAG_ZERO, IPP_TAG_ZERO, 0));
856 }
857
858
859 /*
860 * 'ippAddString()' - Add a language-encoded string to an IPP message.
861 *
862 * The @code ipp@ parameter refers to an IPP message previously created using
863 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
864 *
865 * The @code group@ parameter specifies the IPP attribute group tag: none
866 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
867 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
868 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
869 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
870 *
871 * Supported string values include charset (@code IPP_TAG_CHARSET@), keyword
872 * (@code IPP_TAG_KEYWORD@), language (@code IPP_TAG_LANGUAGE@), mimeMediaType
873 * (@code IPP_TAG_MIMETYPE@), name (@code IPP_TAG_NAME@), nameWithLanguage
874 * (@code IPP_TAG_NAMELANG), text (@code IPP_TAG_TEXT@), textWithLanguage
875 * (@code IPP_TAG_TEXTLANG@), uri (@code IPP_TAG_URI@), and uriScheme
876 * (@code IPP_TAG_URISCHEME@).
877 *
878 * The @code language@ parameter must be non-@code NULL@ for nameWithLanguage and
879 * textWithLanguage string values and must be @code NULL@ for all other string values.
880 */
881
882 ipp_attribute_t * /* O - New attribute */
883 ippAddString(ipp_t *ipp, /* I - IPP message */
884 ipp_tag_t group, /* I - IPP group */
885 ipp_tag_t value_tag, /* I - Type of attribute */
886 const char *name, /* I - Name of attribute */
887 const char *language, /* I - Language code */
888 const char *value) /* I - Value */
889 {
890 ipp_tag_t temp_tag; /* Temporary value tag (masked) */
891 ipp_attribute_t *attr; /* New attribute */
892 char code[IPP_MAX_LANGUAGE];
893 /* Charset/language code buffer */
894
895
896 DEBUG_printf(("ippAddString(ipp=%p, group=%02x(%s), value_tag=%02x(%s), name=\"%s\", language=\"%s\", value=\"%s\")", (void *)ipp, group, ippTagString(group), value_tag, ippTagString(value_tag), name, language, value));
897
898 /*
899 * Range check input...
900 */
901
902 temp_tag = (ipp_tag_t)((int)value_tag & IPP_TAG_CUPS_MASK);
903
904 #if 0
905 if (!ipp || !name || group < IPP_TAG_ZERO ||
906 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
907 (temp_tag < IPP_TAG_TEXT && temp_tag != IPP_TAG_TEXTLANG &&
908 temp_tag != IPP_TAG_NAMELANG) || temp_tag > IPP_TAG_MIMETYPE)
909 return (NULL);
910
911 if ((temp_tag == IPP_TAG_TEXTLANG || temp_tag == IPP_TAG_NAMELANG)
912 != (language != NULL))
913 return (NULL);
914 #else
915 if (!ipp || !name || group < IPP_TAG_ZERO ||
916 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE)
917 return (NULL);
918 #endif /* 0 */
919
920 /*
921 * See if we need to map charset, language, or locale values...
922 */
923
924 if (language && ((int)value_tag & IPP_TAG_CUPS_CONST) &&
925 strcmp(language, ipp_lang_code(language, code, sizeof(code))))
926 value_tag = temp_tag; /* Don't do a fast copy */
927 else if (value && value_tag == (ipp_tag_t)(IPP_TAG_CHARSET | IPP_TAG_CUPS_CONST) &&
928 strcmp(value, ipp_get_code(value, code, sizeof(code))))
929 value_tag = temp_tag; /* Don't do a fast copy */
930 else if (value && value_tag == (ipp_tag_t)(IPP_TAG_LANGUAGE | IPP_TAG_CUPS_CONST) &&
931 strcmp(value, ipp_lang_code(value, code, sizeof(code))))
932 value_tag = temp_tag; /* Don't do a fast copy */
933
934 /*
935 * Create the attribute...
936 */
937
938 if ((attr = ipp_add_attr(ipp, name, group, value_tag, 1)) == NULL)
939 return (NULL);
940
941 /*
942 * Initialize the attribute data...
943 */
944
945 if ((int)value_tag & IPP_TAG_CUPS_CONST)
946 {
947 attr->values[0].string.language = (char *)language;
948 attr->values[0].string.text = (char *)value;
949 }
950 else
951 {
952 if (language)
953 attr->values[0].string.language = _cupsStrAlloc(ipp_lang_code(language, code,
954 sizeof(code)));
955
956 if (value)
957 {
958 if (value_tag == IPP_TAG_CHARSET)
959 attr->values[0].string.text = _cupsStrAlloc(ipp_get_code(value, code,
960 sizeof(code)));
961 else if (value_tag == IPP_TAG_LANGUAGE)
962 attr->values[0].string.text = _cupsStrAlloc(ipp_lang_code(value, code,
963 sizeof(code)));
964 else
965 attr->values[0].string.text = _cupsStrAlloc(value);
966 }
967 }
968
969 return (attr);
970 }
971
972
973 /*
974 * 'ippAddStringf()' - Add a formatted string to an IPP message.
975 *
976 * The @code ipp@ parameter refers to an IPP message previously created using
977 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
978 *
979 * The @code group@ parameter specifies the IPP attribute group tag: none
980 * (@code IPP_TAG_ZERO@, for member attributes), document
981 * (@code IPP_TAG_DOCUMENT@), event notification
982 * (@code IPP_TAG_EVENT_NOTIFICATION@), operation (@code IPP_TAG_OPERATION@),
983 * printer (@code IPP_TAG_PRINTER@), subscription (@code IPP_TAG_SUBSCRIPTION@),
984 * or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
985 *
986 * Supported string values include charset (@code IPP_TAG_CHARSET@), keyword
987 * (@code IPP_TAG_KEYWORD@), language (@code IPP_TAG_LANGUAGE@), mimeMediaType
988 * (@code IPP_TAG_MIMETYPE@), name (@code IPP_TAG_NAME@), nameWithLanguage
989 * (@code IPP_TAG_NAMELANG), text (@code IPP_TAG_TEXT@), textWithLanguage
990 * (@code IPP_TAG_TEXTLANG@), uri (@code IPP_TAG_URI@), and uriScheme
991 * (@code IPP_TAG_URISCHEME@).
992 *
993 * The @code language@ parameter must be non-@code NULL@ for nameWithLanguage
994 * and textWithLanguage string values and must be @code NULL@ for all other
995 * string values.
996 *
997 * The @code format@ parameter uses formatting characters compatible with the
998 * printf family of standard functions. Additional arguments follow it as
999 * needed. The formatted string is truncated as needed to the maximum length of
1000 * the corresponding value type.
1001 *
1002 * @since CUPS 1.7/macOS 10.9@
1003 */
1004
1005 ipp_attribute_t * /* O - New attribute */
1006 ippAddStringf(ipp_t *ipp, /* I - IPP message */
1007 ipp_tag_t group, /* I - IPP group */
1008 ipp_tag_t value_tag, /* I - Type of attribute */
1009 const char *name, /* I - Name of attribute */
1010 const char *language, /* I - Language code (@code NULL@ for default) */
1011 const char *format, /* I - Printf-style format string */
1012 ...) /* I - Additional arguments as needed */
1013 {
1014 ipp_attribute_t *attr; /* New attribute */
1015 va_list ap; /* Argument pointer */
1016
1017
1018 va_start(ap, format);
1019 attr = ippAddStringfv(ipp, group, value_tag, name, language, format, ap);
1020 va_end(ap);
1021
1022 return (attr);
1023 }
1024
1025
1026 /*
1027 * 'ippAddStringfv()' - Add a formatted string to an IPP message.
1028 *
1029 * The @code ipp@ parameter refers to an IPP message previously created using
1030 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
1031 *
1032 * The @code group@ parameter specifies the IPP attribute group tag: none
1033 * (@code IPP_TAG_ZERO@, for member attributes), document
1034 * (@code IPP_TAG_DOCUMENT@), event notification
1035 * (@code IPP_TAG_EVENT_NOTIFICATION@), operation (@code IPP_TAG_OPERATION@),
1036 * printer (@code IPP_TAG_PRINTER@), subscription (@code IPP_TAG_SUBSCRIPTION@),
1037 * or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
1038 *
1039 * Supported string values include charset (@code IPP_TAG_CHARSET@), keyword
1040 * (@code IPP_TAG_KEYWORD@), language (@code IPP_TAG_LANGUAGE@), mimeMediaType
1041 * (@code IPP_TAG_MIMETYPE@), name (@code IPP_TAG_NAME@), nameWithLanguage
1042 * (@code IPP_TAG_NAMELANG), text (@code IPP_TAG_TEXT@), textWithLanguage
1043 * (@code IPP_TAG_TEXTLANG@), uri (@code IPP_TAG_URI@), and uriScheme
1044 * (@code IPP_TAG_URISCHEME@).
1045 *
1046 * The @code language@ parameter must be non-@code NULL@ for nameWithLanguage
1047 * and textWithLanguage string values and must be @code NULL@ for all other
1048 * string values.
1049 *
1050 * The @code format@ parameter uses formatting characters compatible with the
1051 * printf family of standard functions. Additional arguments are passed in the
1052 * stdarg pointer @code ap@. The formatted string is truncated as needed to the
1053 * maximum length of the corresponding value type.
1054 *
1055 * @since CUPS 1.7/macOS 10.9@
1056 */
1057
1058 ipp_attribute_t * /* O - New attribute */
1059 ippAddStringfv(ipp_t *ipp, /* I - IPP message */
1060 ipp_tag_t group, /* I - IPP group */
1061 ipp_tag_t value_tag, /* I - Type of attribute */
1062 const char *name, /* I - Name of attribute */
1063 const char *language, /* I - Language code (@code NULL@ for default) */
1064 const char *format, /* I - Printf-style format string */
1065 va_list ap) /* I - Additional arguments */
1066 {
1067 char buffer[IPP_MAX_TEXT + 4];
1068 /* Formatted text string */
1069 ssize_t bytes, /* Length of formatted value */
1070 max_bytes; /* Maximum number of bytes for value */
1071
1072
1073 /*
1074 * Range check input...
1075 */
1076
1077 if (!ipp || !name || group < IPP_TAG_ZERO ||
1078 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
1079 (value_tag < IPP_TAG_TEXT && value_tag != IPP_TAG_TEXTLANG &&
1080 value_tag != IPP_TAG_NAMELANG) || value_tag > IPP_TAG_MIMETYPE ||
1081 !format)
1082 return (NULL);
1083
1084 if ((value_tag == IPP_TAG_TEXTLANG || value_tag == IPP_TAG_NAMELANG)
1085 != (language != NULL))
1086 return (NULL);
1087
1088 /*
1089 * Format the string...
1090 */
1091
1092 if (!strcmp(format, "%s"))
1093 {
1094 /*
1095 * Optimize the simple case...
1096 */
1097
1098 const char *s = va_arg(ap, char *);
1099
1100 if (!s)
1101 s = "(null)";
1102
1103 bytes = (ssize_t)strlen(s);
1104 strlcpy(buffer, s, sizeof(buffer));
1105 }
1106 else
1107 {
1108 /*
1109 * Do a full formatting of the message...
1110 */
1111
1112 if ((bytes = vsnprintf(buffer, sizeof(buffer), format, ap)) < 0)
1113 return (NULL);
1114 }
1115
1116 /*
1117 * Limit the length of the string...
1118 */
1119
1120 switch (value_tag)
1121 {
1122 default :
1123 case IPP_TAG_TEXT :
1124 case IPP_TAG_TEXTLANG :
1125 max_bytes = IPP_MAX_TEXT;
1126 break;
1127
1128 case IPP_TAG_NAME :
1129 case IPP_TAG_NAMELANG :
1130 max_bytes = IPP_MAX_NAME;
1131 break;
1132
1133 case IPP_TAG_CHARSET :
1134 max_bytes = IPP_MAX_CHARSET;
1135 break;
1136
1137 case IPP_TAG_KEYWORD :
1138 max_bytes = IPP_MAX_KEYWORD;
1139 break;
1140
1141 case IPP_TAG_LANGUAGE :
1142 max_bytes = IPP_MAX_LANGUAGE;
1143 break;
1144
1145 case IPP_TAG_MIMETYPE :
1146 max_bytes = IPP_MAX_MIMETYPE;
1147 break;
1148
1149 case IPP_TAG_URI :
1150 max_bytes = IPP_MAX_URI;
1151 break;
1152
1153 case IPP_TAG_URISCHEME :
1154 max_bytes = IPP_MAX_URISCHEME;
1155 break;
1156 }
1157
1158 if (bytes >= max_bytes)
1159 {
1160 char *bufmax, /* Buffer at max_bytes */
1161 *bufptr; /* Pointer into buffer */
1162
1163 bufptr = buffer + strlen(buffer) - 1;
1164 bufmax = buffer + max_bytes - 1;
1165
1166 while (bufptr > bufmax)
1167 {
1168 if (*bufptr & 0x80)
1169 {
1170 while ((*bufptr & 0xc0) == 0x80 && bufptr > buffer)
1171 bufptr --;
1172 }
1173
1174 bufptr --;
1175 }
1176
1177 *bufptr = '\0';
1178 }
1179
1180 /*
1181 * Add the formatted string and return...
1182 */
1183
1184 return (ippAddString(ipp, group, value_tag, name, language, buffer));
1185 }
1186
1187
1188 /*
1189 * 'ippAddStrings()' - Add language-encoded strings to an IPP message.
1190 *
1191 * The @code ipp@ parameter refers to an IPP message previously created using
1192 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
1193 *
1194 * The @code group@ parameter specifies the IPP attribute group tag: none
1195 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
1196 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
1197 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
1198 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
1199 *
1200 * Supported string values include charset (@code IPP_TAG_CHARSET@), keyword
1201 * (@code IPP_TAG_KEYWORD@), language (@code IPP_TAG_LANGUAGE@), mimeMediaType
1202 * (@code IPP_TAG_MIMETYPE@), name (@code IPP_TAG_NAME@), nameWithLanguage
1203 * (@code IPP_TAG_NAMELANG), text (@code IPP_TAG_TEXT@), textWithLanguage
1204 * (@code IPP_TAG_TEXTLANG@), uri (@code IPP_TAG_URI@), and uriScheme
1205 * (@code IPP_TAG_URISCHEME@).
1206 *
1207 * The @code language@ parameter must be non-@code NULL@ for nameWithLanguage and
1208 * textWithLanguage string values and must be @code NULL@ for all other string values.
1209 */
1210
1211 ipp_attribute_t * /* O - New attribute */
1212 ippAddStrings(
1213 ipp_t *ipp, /* I - IPP message */
1214 ipp_tag_t group, /* I - IPP group */
1215 ipp_tag_t value_tag, /* I - Type of attribute */
1216 const char *name, /* I - Name of attribute */
1217 int num_values, /* I - Number of values */
1218 const char *language, /* I - Language code (@code NULL@ for default) */
1219 const char * const *values) /* I - Values */
1220 {
1221 int i; /* Looping var */
1222 ipp_tag_t temp_tag; /* Temporary value tag (masked) */
1223 ipp_attribute_t *attr; /* New attribute */
1224 _ipp_value_t *value; /* Current value */
1225 char code[32]; /* Language/charset value buffer */
1226
1227
1228 DEBUG_printf(("ippAddStrings(ipp=%p, group=%02x(%s), value_tag=%02x(%s), name=\"%s\", num_values=%d, language=\"%s\", values=%p)", (void *)ipp, group, ippTagString(group), value_tag, ippTagString(value_tag), name, num_values, language, (void *)values));
1229
1230 /*
1231 * Range check input...
1232 */
1233
1234 temp_tag = (ipp_tag_t)((int)value_tag & IPP_TAG_CUPS_MASK);
1235
1236 #if 0
1237 if (!ipp || !name || group < IPP_TAG_ZERO ||
1238 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
1239 (temp_tag < IPP_TAG_TEXT && temp_tag != IPP_TAG_TEXTLANG &&
1240 temp_tag != IPP_TAG_NAMELANG) || temp_tag > IPP_TAG_MIMETYPE ||
1241 num_values < 1)
1242 return (NULL);
1243
1244 if ((temp_tag == IPP_TAG_TEXTLANG || temp_tag == IPP_TAG_NAMELANG)
1245 != (language != NULL))
1246 return (NULL);
1247 #else
1248 if (!ipp || !name || group < IPP_TAG_ZERO ||
1249 group == IPP_TAG_END || group >= IPP_TAG_UNSUPPORTED_VALUE ||
1250 num_values < 1)
1251 return (NULL);
1252 #endif /* 0 */
1253
1254 /*
1255 * See if we need to map charset, language, or locale values...
1256 */
1257
1258 if (language && ((int)value_tag & IPP_TAG_CUPS_CONST) &&
1259 strcmp(language, ipp_lang_code(language, code, sizeof(code))))
1260 value_tag = temp_tag; /* Don't do a fast copy */
1261 else if (values && value_tag == (ipp_tag_t)(IPP_TAG_CHARSET | IPP_TAG_CUPS_CONST))
1262 {
1263 for (i = 0; i < num_values; i ++)
1264 if (strcmp(values[i], ipp_get_code(values[i], code, sizeof(code))))
1265 {
1266 value_tag = temp_tag; /* Don't do a fast copy */
1267 break;
1268 }
1269 }
1270 else if (values && value_tag == (ipp_tag_t)(IPP_TAG_LANGUAGE | IPP_TAG_CUPS_CONST))
1271 {
1272 for (i = 0; i < num_values; i ++)
1273 if (strcmp(values[i], ipp_lang_code(values[i], code, sizeof(code))))
1274 {
1275 value_tag = temp_tag; /* Don't do a fast copy */
1276 break;
1277 }
1278 }
1279
1280 /*
1281 * Create the attribute...
1282 */
1283
1284 if ((attr = ipp_add_attr(ipp, name, group, value_tag, num_values)) == NULL)
1285 return (NULL);
1286
1287 /*
1288 * Initialize the attribute data...
1289 */
1290
1291 for (i = num_values, value = attr->values;
1292 i > 0;
1293 i --, value ++)
1294 {
1295 if (language)
1296 {
1297 if (value == attr->values)
1298 {
1299 if ((int)value_tag & IPP_TAG_CUPS_CONST)
1300 value->string.language = (char *)language;
1301 else
1302 value->string.language = _cupsStrAlloc(ipp_lang_code(language, code,
1303 sizeof(code)));
1304 }
1305 else
1306 value->string.language = attr->values[0].string.language;
1307 }
1308
1309 if (values)
1310 {
1311 if ((int)value_tag & IPP_TAG_CUPS_CONST)
1312 value->string.text = (char *)*values++;
1313 else if (value_tag == IPP_TAG_CHARSET)
1314 value->string.text = _cupsStrAlloc(ipp_get_code(*values++, code, sizeof(code)));
1315 else if (value_tag == IPP_TAG_LANGUAGE)
1316 value->string.text = _cupsStrAlloc(ipp_lang_code(*values++, code, sizeof(code)));
1317 else
1318 value->string.text = _cupsStrAlloc(*values++);
1319 }
1320 }
1321
1322 return (attr);
1323 }
1324
1325
1326 /*
1327 * 'ippContainsInteger()' - Determine whether an attribute contains the
1328 * specified value or is within the list of ranges.
1329 *
1330 * Returns non-zero when the attribute contains either a matching integer or
1331 * enum value, or the value falls within one of the rangeOfInteger values for
1332 * the attribute.
1333 *
1334 * @since CUPS 1.7/macOS 10.9@
1335 */
1336
1337 int /* O - 1 on a match, 0 on no match */
1338 ippContainsInteger(
1339 ipp_attribute_t *attr, /* I - Attribute */
1340 int value) /* I - Integer/enum value */
1341 {
1342 int i; /* Looping var */
1343 _ipp_value_t *avalue; /* Current attribute value */
1344
1345
1346 /*
1347 * Range check input...
1348 */
1349
1350 if (!attr)
1351 return (0);
1352
1353 if (attr->value_tag != IPP_TAG_INTEGER && attr->value_tag != IPP_TAG_ENUM &&
1354 attr->value_tag != IPP_TAG_RANGE)
1355 return (0);
1356
1357 /*
1358 * Compare...
1359 */
1360
1361 if (attr->value_tag == IPP_TAG_RANGE)
1362 {
1363 for (i = attr->num_values, avalue = attr->values; i > 0; i --, avalue ++)
1364 if (value >= avalue->range.lower && value <= avalue->range.upper)
1365 return (1);
1366 }
1367 else
1368 {
1369 for (i = attr->num_values, avalue = attr->values; i > 0; i --, avalue ++)
1370 if (value == avalue->integer)
1371 return (1);
1372 }
1373
1374 return (0);
1375 }
1376
1377
1378 /*
1379 * 'ippContainsString()' - Determine whether an attribute contains the
1380 * specified string value.
1381 *
1382 * Returns non-zero when the attribute contains a matching charset, keyword,
1383 * naturalLanguage, mimeMediaType, name, text, uri, or uriScheme value.
1384 *
1385 * @since CUPS 1.7/macOS 10.9@
1386 */
1387
1388 int /* O - 1 on a match, 0 on no match */
1389 ippContainsString(
1390 ipp_attribute_t *attr, /* I - Attribute */
1391 const char *value) /* I - String value */
1392 {
1393 int i; /* Looping var */
1394 _ipp_value_t *avalue; /* Current attribute value */
1395
1396
1397 DEBUG_printf(("ippContainsString(attr=%p, value=\"%s\")", (void *)attr, value));
1398
1399 /*
1400 * Range check input...
1401 */
1402
1403 if (!attr || !value)
1404 {
1405 DEBUG_puts("1ippContainsString: Returning 0 (bad input)");
1406 return (0);
1407 }
1408
1409 /*
1410 * Compare...
1411 */
1412
1413 DEBUG_printf(("1ippContainsString: attr %s, %s with %d values.",
1414 attr->name, ippTagString(attr->value_tag),
1415 attr->num_values));
1416
1417 switch (attr->value_tag & IPP_TAG_CUPS_MASK)
1418 {
1419 case IPP_TAG_CHARSET :
1420 case IPP_TAG_KEYWORD :
1421 case IPP_TAG_LANGUAGE :
1422 case IPP_TAG_URI :
1423 case IPP_TAG_URISCHEME :
1424 for (i = attr->num_values, avalue = attr->values;
1425 i > 0;
1426 i --, avalue ++)
1427 {
1428 DEBUG_printf(("1ippContainsString: value[%d]=\"%s\"",
1429 attr->num_values - i, avalue->string.text));
1430
1431 if (!strcmp(value, avalue->string.text))
1432 {
1433 DEBUG_puts("1ippContainsString: Returning 1 (match)");
1434 return (1);
1435 }
1436 }
1437
1438 case IPP_TAG_MIMETYPE :
1439 case IPP_TAG_NAME :
1440 case IPP_TAG_NAMELANG :
1441 case IPP_TAG_TEXT :
1442 case IPP_TAG_TEXTLANG :
1443 for (i = attr->num_values, avalue = attr->values;
1444 i > 0;
1445 i --, avalue ++)
1446 {
1447 DEBUG_printf(("1ippContainsString: value[%d]=\"%s\"",
1448 attr->num_values - i, avalue->string.text));
1449
1450 if (!_cups_strcasecmp(value, avalue->string.text))
1451 {
1452 DEBUG_puts("1ippContainsString: Returning 1 (match)");
1453 return (1);
1454 }
1455 }
1456
1457 default :
1458 break;
1459 }
1460
1461 DEBUG_puts("1ippContainsString: Returning 0 (no match)");
1462
1463 return (0);
1464 }
1465
1466
1467 /*
1468 * 'ippCopyAttribute()' - Copy an attribute.
1469 *
1470 * The specified attribute, @code attr@, is copied to the destination IPP message.
1471 * When @code quickcopy@ is non-zero, a "shallow" reference copy of the attribute is
1472 * created - this should only be done as long as the original source IPP message will
1473 * not be freed for the life of the destination.
1474 *
1475 * @since CUPS 1.6/macOS 10.8@
1476 */
1477
1478
1479 ipp_attribute_t * /* O - New attribute */
1480 ippCopyAttribute(
1481 ipp_t *dst, /* I - Destination IPP message */
1482 ipp_attribute_t *srcattr, /* I - Attribute to copy */
1483 int quickcopy) /* I - 1 for a referenced copy, 0 for normal */
1484 {
1485 int i; /* Looping var */
1486 ipp_attribute_t *dstattr; /* Destination attribute */
1487 _ipp_value_t *srcval, /* Source value */
1488 *dstval; /* Destination value */
1489
1490
1491 DEBUG_printf(("ippCopyAttribute(dst=%p, srcattr=%p, quickcopy=%d)", (void *)dst, (void *)srcattr, quickcopy));
1492
1493 /*
1494 * Range check input...
1495 */
1496
1497 if (!dst || !srcattr)
1498 return (NULL);
1499
1500 /*
1501 * Copy it...
1502 */
1503
1504 quickcopy = quickcopy ? IPP_TAG_CUPS_CONST : 0;
1505
1506 switch (srcattr->value_tag & ~IPP_TAG_CUPS_CONST)
1507 {
1508 case IPP_TAG_ZERO :
1509 dstattr = ippAddSeparator(dst);
1510 break;
1511
1512 case IPP_TAG_INTEGER :
1513 case IPP_TAG_ENUM :
1514 dstattr = ippAddIntegers(dst, srcattr->group_tag, srcattr->value_tag,
1515 srcattr->name, srcattr->num_values, NULL);
1516 if (!dstattr)
1517 break;
1518
1519 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1520 i > 0;
1521 i --, srcval ++, dstval ++)
1522 dstval->integer = srcval->integer;
1523 break;
1524
1525 case IPP_TAG_BOOLEAN :
1526 dstattr = ippAddBooleans(dst, srcattr->group_tag, srcattr->name,
1527 srcattr->num_values, NULL);
1528 if (!dstattr)
1529 break;
1530
1531 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1532 i > 0;
1533 i --, srcval ++, dstval ++)
1534 dstval->boolean = srcval->boolean;
1535 break;
1536
1537 case IPP_TAG_TEXT :
1538 case IPP_TAG_NAME :
1539 case IPP_TAG_KEYWORD :
1540 case IPP_TAG_URI :
1541 case IPP_TAG_URISCHEME :
1542 case IPP_TAG_CHARSET :
1543 case IPP_TAG_LANGUAGE :
1544 case IPP_TAG_MIMETYPE :
1545 dstattr = ippAddStrings(dst, srcattr->group_tag,
1546 (ipp_tag_t)(srcattr->value_tag | quickcopy),
1547 srcattr->name, srcattr->num_values, NULL, NULL);
1548 if (!dstattr)
1549 break;
1550
1551 if (quickcopy)
1552 {
1553 for (i = srcattr->num_values, srcval = srcattr->values,
1554 dstval = dstattr->values;
1555 i > 0;
1556 i --, srcval ++, dstval ++)
1557 dstval->string.text = srcval->string.text;
1558 }
1559 else if (srcattr->value_tag & IPP_TAG_CUPS_CONST)
1560 {
1561 for (i = srcattr->num_values, srcval = srcattr->values,
1562 dstval = dstattr->values;
1563 i > 0;
1564 i --, srcval ++, dstval ++)
1565 dstval->string.text = _cupsStrAlloc(srcval->string.text);
1566 }
1567 else
1568 {
1569 for (i = srcattr->num_values, srcval = srcattr->values,
1570 dstval = dstattr->values;
1571 i > 0;
1572 i --, srcval ++, dstval ++)
1573 dstval->string.text = _cupsStrRetain(srcval->string.text);
1574 }
1575 break;
1576
1577 case IPP_TAG_DATE :
1578 if (srcattr->num_values != 1)
1579 return (NULL);
1580
1581 dstattr = ippAddDate(dst, srcattr->group_tag, srcattr->name,
1582 srcattr->values[0].date);
1583 break;
1584
1585 case IPP_TAG_RESOLUTION :
1586 dstattr = ippAddResolutions(dst, srcattr->group_tag, srcattr->name,
1587 srcattr->num_values, IPP_RES_PER_INCH,
1588 NULL, NULL);
1589 if (!dstattr)
1590 break;
1591
1592 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1593 i > 0;
1594 i --, srcval ++, dstval ++)
1595 {
1596 dstval->resolution.xres = srcval->resolution.xres;
1597 dstval->resolution.yres = srcval->resolution.yres;
1598 dstval->resolution.units = srcval->resolution.units;
1599 }
1600 break;
1601
1602 case IPP_TAG_RANGE :
1603 dstattr = ippAddRanges(dst, srcattr->group_tag, srcattr->name,
1604 srcattr->num_values, NULL, NULL);
1605 if (!dstattr)
1606 break;
1607
1608 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1609 i > 0;
1610 i --, srcval ++, dstval ++)
1611 {
1612 dstval->range.lower = srcval->range.lower;
1613 dstval->range.upper = srcval->range.upper;
1614 }
1615 break;
1616
1617 case IPP_TAG_TEXTLANG :
1618 case IPP_TAG_NAMELANG :
1619 dstattr = ippAddStrings(dst, srcattr->group_tag,
1620 (ipp_tag_t)(srcattr->value_tag | quickcopy),
1621 srcattr->name, srcattr->num_values, NULL, NULL);
1622 if (!dstattr)
1623 break;
1624
1625 if (quickcopy)
1626 {
1627 for (i = srcattr->num_values, srcval = srcattr->values,
1628 dstval = dstattr->values;
1629 i > 0;
1630 i --, srcval ++, dstval ++)
1631 {
1632 dstval->string.language = srcval->string.language;
1633 dstval->string.text = srcval->string.text;
1634 }
1635 }
1636 else if (srcattr->value_tag & IPP_TAG_CUPS_CONST)
1637 {
1638 for (i = srcattr->num_values, srcval = srcattr->values,
1639 dstval = dstattr->values;
1640 i > 0;
1641 i --, srcval ++, dstval ++)
1642 {
1643 if (srcval == srcattr->values)
1644 dstval->string.language = _cupsStrAlloc(srcval->string.language);
1645 else
1646 dstval->string.language = dstattr->values[0].string.language;
1647
1648 dstval->string.text = _cupsStrAlloc(srcval->string.text);
1649 }
1650 }
1651 else
1652 {
1653 for (i = srcattr->num_values, srcval = srcattr->values,
1654 dstval = dstattr->values;
1655 i > 0;
1656 i --, srcval ++, dstval ++)
1657 {
1658 if (srcval == srcattr->values)
1659 dstval->string.language = _cupsStrRetain(srcval->string.language);
1660 else
1661 dstval->string.language = dstattr->values[0].string.language;
1662
1663 dstval->string.text = _cupsStrRetain(srcval->string.text);
1664 }
1665 }
1666 break;
1667
1668 case IPP_TAG_BEGIN_COLLECTION :
1669 dstattr = ippAddCollections(dst, srcattr->group_tag, srcattr->name,
1670 srcattr->num_values, NULL);
1671 if (!dstattr)
1672 break;
1673
1674 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1675 i > 0;
1676 i --, srcval ++, dstval ++)
1677 {
1678 dstval->collection = srcval->collection;
1679 srcval->collection->use ++;
1680 }
1681 break;
1682
1683 case IPP_TAG_STRING :
1684 default :
1685 /* TODO: Implement quick copy for unknown/octetString values */
1686 dstattr = ippAddIntegers(dst, srcattr->group_tag, srcattr->value_tag,
1687 srcattr->name, srcattr->num_values, NULL);
1688 if (!dstattr)
1689 break;
1690
1691 for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
1692 i > 0;
1693 i --, srcval ++, dstval ++)
1694 {
1695 dstval->unknown.length = srcval->unknown.length;
1696
1697 if (dstval->unknown.length > 0)
1698 {
1699 if ((dstval->unknown.data = malloc((size_t)dstval->unknown.length)) == NULL)
1700 dstval->unknown.length = 0;
1701 else
1702 memcpy(dstval->unknown.data, srcval->unknown.data, (size_t)dstval->unknown.length);
1703 }
1704 }
1705 break; /* anti-compiler-warning-code */
1706 }
1707
1708 return (dstattr);
1709 }
1710
1711
1712 /*
1713 * 'ippCopyAttributes()' - Copy attributes from one IPP message to another.
1714 *
1715 * Zero or more attributes are copied from the source IPP message, @code src@, to the
1716 * destination IPP message, @code dst@. When @code quickcopy@ is non-zero, a "shallow"
1717 * reference copy of the attribute is created - this should only be done as long as the
1718 * original source IPP message will not be freed for the life of the destination.
1719 *
1720 * The @code cb@ and @code context@ parameters provide a generic way to "filter" the
1721 * attributes that are copied - the function must return 1 to copy the attribute or
1722 * 0 to skip it. The function may also choose to do a partial copy of the source attribute
1723 * itself.
1724 *
1725 * @since CUPS 1.6/macOS 10.8@
1726 */
1727
1728 int /* O - 1 on success, 0 on error */
1729 ippCopyAttributes(
1730 ipp_t *dst, /* I - Destination IPP message */
1731 ipp_t *src, /* I - Source IPP message */
1732 int quickcopy, /* I - 1 for a referenced copy, 0 for normal */
1733 ipp_copycb_t cb, /* I - Copy callback or @code NULL@ for none */
1734 void *context) /* I - Context pointer */
1735 {
1736 ipp_attribute_t *srcattr; /* Source attribute */
1737
1738
1739 DEBUG_printf(("ippCopyAttributes(dst=%p, src=%p, quickcopy=%d, cb=%p, context=%p)", (void *)dst, (void *)src, quickcopy, (void *)cb, context));
1740
1741 /*
1742 * Range check input...
1743 */
1744
1745 if (!dst || !src)
1746 return (0);
1747
1748 /*
1749 * Loop through source attributes and copy as needed...
1750 */
1751
1752 for (srcattr = src->attrs; srcattr; srcattr = srcattr->next)
1753 if (!cb || (*cb)(context, dst, srcattr))
1754 if (!ippCopyAttribute(dst, srcattr, quickcopy))
1755 return (0);
1756
1757 return (1);
1758 }
1759
1760
1761 /*
1762 * 'ippDateToTime()' - Convert from RFC 2579 Date/Time format to time in
1763 * seconds.
1764 */
1765
1766 time_t /* O - UNIX time value */
1767 ippDateToTime(const ipp_uchar_t *date) /* I - RFC 2579 date info */
1768 {
1769 struct tm unixdate; /* UNIX date/time info */
1770 time_t t; /* Computed time */
1771
1772
1773 if (!date)
1774 return (0);
1775
1776 memset(&unixdate, 0, sizeof(unixdate));
1777
1778 /*
1779 * RFC-2579 date/time format is:
1780 *
1781 * Byte(s) Description
1782 * ------- -----------
1783 * 0-1 Year (0 to 65535)
1784 * 2 Month (1 to 12)
1785 * 3 Day (1 to 31)
1786 * 4 Hours (0 to 23)
1787 * 5 Minutes (0 to 59)
1788 * 6 Seconds (0 to 60, 60 = "leap second")
1789 * 7 Deciseconds (0 to 9)
1790 * 8 +/- UTC
1791 * 9 UTC hours (0 to 11)
1792 * 10 UTC minutes (0 to 59)
1793 */
1794
1795 unixdate.tm_year = ((date[0] << 8) | date[1]) - 1900;
1796 unixdate.tm_mon = date[2] - 1;
1797 unixdate.tm_mday = date[3];
1798 unixdate.tm_hour = date[4];
1799 unixdate.tm_min = date[5];
1800 unixdate.tm_sec = date[6];
1801
1802 t = mktime(&unixdate);
1803
1804 if (date[8] == '-')
1805 t += date[9] * 3600 + date[10] * 60;
1806 else
1807 t -= date[9] * 3600 + date[10] * 60;
1808
1809 return (t);
1810 }
1811
1812
1813 /*
1814 * 'ippDelete()' - Delete an IPP message.
1815 */
1816
1817 void
1818 ippDelete(ipp_t *ipp) /* I - IPP message */
1819 {
1820 ipp_attribute_t *attr, /* Current attribute */
1821 *next; /* Next attribute */
1822
1823
1824 DEBUG_printf(("ippDelete(ipp=%p)", (void *)ipp));
1825
1826 if (!ipp)
1827 return;
1828
1829 ipp->use --;
1830 if (ipp->use > 0)
1831 return;
1832
1833 for (attr = ipp->attrs; attr != NULL; attr = next)
1834 {
1835 next = attr->next;
1836
1837 ipp_free_values(attr, 0, attr->num_values);
1838
1839 if (attr->name)
1840 _cupsStrFree(attr->name);
1841
1842 free(attr);
1843 }
1844
1845 free(ipp);
1846 }
1847
1848
1849 /*
1850 * 'ippDeleteAttribute()' - Delete a single attribute in an IPP message.
1851 *
1852 * @since CUPS 1.1.19/macOS 10.3@
1853 */
1854
1855 void
1856 ippDeleteAttribute(
1857 ipp_t *ipp, /* I - IPP message */
1858 ipp_attribute_t *attr) /* I - Attribute to delete */
1859 {
1860 ipp_attribute_t *current, /* Current attribute */
1861 *prev; /* Previous attribute */
1862
1863
1864 DEBUG_printf(("ippDeleteAttribute(ipp=%p, attr=%p(%s))", (void *)ipp, (void *)attr, attr ? attr->name : "(null)"));
1865
1866 /*
1867 * Range check input...
1868 */
1869
1870 if (!attr)
1871 return;
1872
1873 /*
1874 * Find the attribute in the list...
1875 */
1876
1877 if (ipp)
1878 {
1879 for (current = ipp->attrs, prev = NULL;
1880 current;
1881 prev = current, current = current->next)
1882 if (current == attr)
1883 {
1884 /*
1885 * Found it, remove the attribute from the list...
1886 */
1887
1888 if (prev)
1889 prev->next = current->next;
1890 else
1891 ipp->attrs = current->next;
1892
1893 if (current == ipp->last)
1894 ipp->last = prev;
1895
1896 break;
1897 }
1898
1899 if (!current)
1900 return;
1901 }
1902
1903 /*
1904 * Free memory used by the attribute...
1905 */
1906
1907 ipp_free_values(attr, 0, attr->num_values);
1908
1909 if (attr->name)
1910 _cupsStrFree(attr->name);
1911
1912 free(attr);
1913 }
1914
1915
1916 /*
1917 * 'ippDeleteValues()' - Delete values in an attribute.
1918 *
1919 * The @code element@ parameter specifies the first value to delete, starting at
1920 * 0. It must be less than the number of values returned by @link ippGetCount@.
1921 *
1922 * The @code attr@ parameter may be modified as a result of setting the value.
1923 *
1924 * Deleting all values in an attribute deletes the attribute.
1925 *
1926 * @since CUPS 1.6/macOS 10.8@
1927 */
1928
1929 int /* O - 1 on success, 0 on failure */
1930 ippDeleteValues(
1931 ipp_t *ipp, /* I - IPP message */
1932 ipp_attribute_t **attr, /* IO - Attribute */
1933 int element, /* I - Index of first value to delete (0-based) */
1934 int count) /* I - Number of values to delete */
1935 {
1936 /*
1937 * Range check input...
1938 */
1939
1940 if (!ipp || !attr || !*attr ||
1941 element < 0 || element >= (*attr)->num_values || count <= 0 ||
1942 (element + count) >= (*attr)->num_values)
1943 return (0);
1944
1945 /*
1946 * If we are deleting all values, just delete the attribute entirely.
1947 */
1948
1949 if (count == (*attr)->num_values)
1950 {
1951 ippDeleteAttribute(ipp, *attr);
1952 *attr = NULL;
1953 return (1);
1954 }
1955
1956 /*
1957 * Otherwise free the values in question and return.
1958 */
1959
1960 ipp_free_values(*attr, element, count);
1961
1962 return (1);
1963 }
1964
1965
1966 /*
1967 * 'ippFindAttribute()' - Find a named attribute in a request.
1968 *
1969 * Starting with CUPS 2.0, the attribute name can contain a hierarchical list
1970 * of attribute and member names separated by slashes, for example
1971 * "media-col/media-size".
1972 */
1973
1974 ipp_attribute_t * /* O - Matching attribute */
1975 ippFindAttribute(ipp_t *ipp, /* I - IPP message */
1976 const char *name, /* I - Name of attribute */
1977 ipp_tag_t type) /* I - Type of attribute */
1978 {
1979 DEBUG_printf(("2ippFindAttribute(ipp=%p, name=\"%s\", type=%02x(%s))", (void *)ipp, name, type, ippTagString(type)));
1980
1981 if (!ipp || !name)
1982 return (NULL);
1983
1984 /*
1985 * Reset the current pointer...
1986 */
1987
1988 ipp->current = NULL;
1989 ipp->atend = 0;
1990
1991 /*
1992 * Search for the attribute...
1993 */
1994
1995 return (ippFindNextAttribute(ipp, name, type));
1996 }
1997
1998
1999 /*
2000 * 'ippFindNextAttribute()' - Find the next named attribute in a request.
2001 *
2002 * Starting with CUPS 2.0, the attribute name can contain a hierarchical list
2003 * of attribute and member names separated by slashes, for example
2004 * "media-col/media-size".
2005 */
2006
2007 ipp_attribute_t * /* O - Matching attribute */
2008 ippFindNextAttribute(ipp_t *ipp, /* I - IPP message */
2009 const char *name, /* I - Name of attribute */
2010 ipp_tag_t type) /* I - Type of attribute */
2011 {
2012 ipp_attribute_t *attr, /* Current atttribute */
2013 *childattr; /* Child attribute */
2014 ipp_tag_t value_tag; /* Value tag */
2015 char parent[1024], /* Parent attribute name */
2016 *child = NULL; /* Child attribute name */
2017
2018
2019 DEBUG_printf(("2ippFindNextAttribute(ipp=%p, name=\"%s\", type=%02x(%s))", (void *)ipp, name, type, ippTagString(type)));
2020
2021 if (!ipp || !name)
2022 return (NULL);
2023
2024 DEBUG_printf(("3ippFindNextAttribute: atend=%d", ipp->atend));
2025
2026 if (ipp->atend)
2027 return (NULL);
2028
2029 if (strchr(name, '/'))
2030 {
2031 /*
2032 * Search for child attribute...
2033 */
2034
2035 strlcpy(parent, name, sizeof(parent));
2036 if ((child = strchr(parent, '/')) == NULL)
2037 {
2038 DEBUG_puts("3ippFindNextAttribute: Attribute name too long.");
2039 return (NULL);
2040 }
2041
2042 *child++ = '\0';
2043
2044 if (ipp->current && ipp->current->name && ipp->current->value_tag == IPP_TAG_BEGIN_COLLECTION && !strcmp(parent, ipp->current->name))
2045 {
2046 while (ipp->curindex < ipp->current->num_values)
2047 {
2048 if ((childattr = ippFindNextAttribute(ipp->current->values[ipp->curindex].collection, child, type)) != NULL)
2049 return (childattr);
2050
2051 ipp->curindex ++;
2052 if (ipp->curindex < ipp->current->num_values && ipp->current->values[ipp->curindex].collection)
2053 ipp->current->values[ipp->curindex].collection->current = NULL;
2054 }
2055
2056 ipp->prev = ipp->current;
2057 ipp->current = ipp->current->next;
2058 ipp->curindex = 0;
2059
2060 if (!ipp->current)
2061 {
2062 ipp->atend = 1;
2063 return (NULL);
2064 }
2065 }
2066
2067 if (!ipp->current)
2068 {
2069 ipp->prev = NULL;
2070 ipp->current = ipp->attrs;
2071 ipp->curindex = 0;
2072 }
2073
2074 name = parent;
2075 attr = ipp->current;
2076 }
2077 else if (ipp->current)
2078 {
2079 ipp->prev = ipp->current;
2080 attr = ipp->current->next;
2081 }
2082 else
2083 {
2084 ipp->prev = NULL;
2085 attr = ipp->attrs;
2086 }
2087
2088 for (; attr != NULL; ipp->prev = attr, attr = attr->next)
2089 {
2090 DEBUG_printf(("4ippFindAttribute: attr=%p, name=\"%s\"", (void *)attr, attr->name));
2091
2092 value_tag = (ipp_tag_t)(attr->value_tag & IPP_TAG_CUPS_MASK);
2093
2094 if (attr->name != NULL && _cups_strcasecmp(attr->name, name) == 0 &&
2095 (value_tag == type || type == IPP_TAG_ZERO || name == parent ||
2096 (value_tag == IPP_TAG_TEXTLANG && type == IPP_TAG_TEXT) ||
2097 (value_tag == IPP_TAG_NAMELANG && type == IPP_TAG_NAME)))
2098 {
2099 ipp->current = attr;
2100
2101 if (name == parent && attr->value_tag == IPP_TAG_BEGIN_COLLECTION)
2102 {
2103 int i; /* Looping var */
2104
2105 for (i = 0; i < attr->num_values; i ++)
2106 {
2107 if ((childattr = ippFindAttribute(attr->values[i].collection, child, type)) != NULL)
2108 {
2109 attr->values[0].collection->curindex = i;
2110 return (childattr);
2111 }
2112 }
2113 }
2114 else
2115 return (attr);
2116 }
2117 }
2118
2119 ipp->current = NULL;
2120 ipp->prev = NULL;
2121 ipp->atend = 1;
2122
2123 return (NULL);
2124 }
2125
2126
2127 /*
2128 * 'ippFirstAttribute()' - Return the first attribute in the message.
2129 *
2130 * @since CUPS 1.6/macOS 10.8@
2131 */
2132
2133 ipp_attribute_t * /* O - First attribute or @code NULL@ if none */
2134 ippFirstAttribute(ipp_t *ipp) /* I - IPP message */
2135 {
2136 /*
2137 * Range check input...
2138 */
2139
2140 if (!ipp)
2141 return (NULL);
2142
2143 /*
2144 * Return the first attribute...
2145 */
2146
2147 return (ipp->current = ipp->attrs);
2148 }
2149
2150
2151 /*
2152 * 'ippGetBoolean()' - Get a boolean value for an attribute.
2153 *
2154 * The @code element@ parameter specifies which value to get from 0 to
2155 * @code ippGetCount(attr)@ - 1.
2156 *
2157 * @since CUPS 1.6/macOS 10.8@
2158 */
2159
2160 int /* O - Boolean value or 0 on error */
2161 ippGetBoolean(ipp_attribute_t *attr, /* I - IPP attribute */
2162 int element) /* I - Value number (0-based) */
2163 {
2164 /*
2165 * Range check input...
2166 */
2167
2168 if (!attr || attr->value_tag != IPP_TAG_BOOLEAN ||
2169 element < 0 || element >= attr->num_values)
2170 return (0);
2171
2172 /*
2173 * Return the value...
2174 */
2175
2176 return (attr->values[element].boolean);
2177 }
2178
2179
2180 /*
2181 * 'ippGetCollection()' - Get a collection value for an attribute.
2182 *
2183 * The @code element@ parameter specifies which value to get from 0 to
2184 * @code ippGetCount(attr)@ - 1.
2185 *
2186 * @since CUPS 1.6/macOS 10.8@
2187 */
2188
2189 ipp_t * /* O - Collection value or @code NULL@ on error */
2190 ippGetCollection(
2191 ipp_attribute_t *attr, /* I - IPP attribute */
2192 int element) /* I - Value number (0-based) */
2193 {
2194 /*
2195 * Range check input...
2196 */
2197
2198 if (!attr || attr->value_tag != IPP_TAG_BEGIN_COLLECTION ||
2199 element < 0 || element >= attr->num_values)
2200 return (NULL);
2201
2202 /*
2203 * Return the value...
2204 */
2205
2206 return (attr->values[element].collection);
2207 }
2208
2209
2210 /*
2211 * 'ippGetCount()' - Get the number of values in an attribute.
2212 *
2213 * @since CUPS 1.6/macOS 10.8@
2214 */
2215
2216 int /* O - Number of values or 0 on error */
2217 ippGetCount(ipp_attribute_t *attr) /* I - IPP attribute */
2218 {
2219 /*
2220 * Range check input...
2221 */
2222
2223 if (!attr)
2224 return (0);
2225
2226 /*
2227 * Return the number of values...
2228 */
2229
2230 return (attr->num_values);
2231 }
2232
2233
2234 /*
2235 * 'ippGetDate()' - Get a dateTime value for an attribute.
2236 *
2237 * The @code element@ parameter specifies which value to get from 0 to
2238 * @code ippGetCount(attr)@ - 1.
2239 *
2240 * @since CUPS 1.6/macOS 10.8@
2241 */
2242
2243 const ipp_uchar_t * /* O - dateTime value or @code NULL@ */
2244 ippGetDate(ipp_attribute_t *attr, /* I - IPP attribute */
2245 int element) /* I - Value number (0-based) */
2246 {
2247 /*
2248 * Range check input...
2249 */
2250
2251 if (!attr || attr->value_tag != IPP_TAG_DATE ||
2252 element < 0 || element >= attr->num_values)
2253 return (NULL);
2254
2255 /*
2256 * Return the value...
2257 */
2258
2259 return (attr->values[element].date);
2260 }
2261
2262
2263 /*
2264 * 'ippGetGroupTag()' - Get the group associated with an attribute.
2265 *
2266 * @since CUPS 1.6/macOS 10.8@
2267 */
2268
2269 ipp_tag_t /* O - Group tag or @code IPP_TAG_ZERO@ on error */
2270 ippGetGroupTag(ipp_attribute_t *attr) /* I - IPP attribute */
2271 {
2272 /*
2273 * Range check input...
2274 */
2275
2276 if (!attr)
2277 return (IPP_TAG_ZERO);
2278
2279 /*
2280 * Return the group...
2281 */
2282
2283 return (attr->group_tag);
2284 }
2285
2286
2287 /*
2288 * 'ippGetInteger()' - Get the integer/enum value for an attribute.
2289 *
2290 * The @code element@ parameter specifies which value to get from 0 to
2291 * @code ippGetCount(attr)@ - 1.
2292 *
2293 * @since CUPS 1.6/macOS 10.8@
2294 */
2295
2296 int /* O - Value or 0 on error */
2297 ippGetInteger(ipp_attribute_t *attr, /* I - IPP attribute */
2298 int element) /* I - Value number (0-based) */
2299 {
2300 /*
2301 * Range check input...
2302 */
2303
2304 if (!attr || (attr->value_tag != IPP_TAG_INTEGER && attr->value_tag != IPP_TAG_ENUM) ||
2305 element < 0 || element >= attr->num_values)
2306 return (0);
2307
2308 /*
2309 * Return the value...
2310 */
2311
2312 return (attr->values[element].integer);
2313 }
2314
2315
2316 /*
2317 * 'ippGetName()' - Get the attribute name.
2318 *
2319 * @since CUPS 1.6/macOS 10.8@
2320 */
2321
2322 const char * /* O - Attribute name or @code NULL@ for separators */
2323 ippGetName(ipp_attribute_t *attr) /* I - IPP attribute */
2324 {
2325 /*
2326 * Range check input...
2327 */
2328
2329 if (!attr)
2330 return (NULL);
2331
2332 /*
2333 * Return the name...
2334 */
2335
2336 return (attr->name);
2337 }
2338
2339
2340 /*
2341 * 'ippGetOctetString()' - Get an octetString value from an IPP attribute.
2342 *
2343 * The @code element@ parameter specifies which value to get from 0 to
2344 * @code ippGetCount(attr)@ - 1.
2345 *
2346 * @since CUPS 1.7/macOS 10.9@
2347 */
2348
2349 void * /* O - Pointer to octetString data */
2350 ippGetOctetString(
2351 ipp_attribute_t *attr, /* I - IPP attribute */
2352 int element, /* I - Value number (0-based) */
2353 int *datalen) /* O - Length of octetString data */
2354 {
2355 /*
2356 * Range check input...
2357 */
2358
2359 if (!attr || attr->value_tag != IPP_TAG_STRING ||
2360 element < 0 || element >= attr->num_values)
2361 {
2362 if (datalen)
2363 *datalen = 0;
2364
2365 return (NULL);
2366 }
2367
2368 /*
2369 * Return the values...
2370 */
2371
2372 if (datalen)
2373 *datalen = attr->values[element].unknown.length;
2374
2375 return (attr->values[element].unknown.data);
2376 }
2377
2378
2379 /*
2380 * 'ippGetOperation()' - Get the operation ID in an IPP message.
2381 *
2382 * @since CUPS 1.6/macOS 10.8@
2383 */
2384
2385 ipp_op_t /* O - Operation ID or 0 on error */
2386 ippGetOperation(ipp_t *ipp) /* I - IPP request message */
2387 {
2388 /*
2389 * Range check input...
2390 */
2391
2392 if (!ipp)
2393 return ((ipp_op_t)0);
2394
2395 /*
2396 * Return the value...
2397 */
2398
2399 return (ipp->request.op.operation_id);
2400 }
2401
2402
2403 /*
2404 * 'ippGetRange()' - Get a rangeOfInteger value from an attribute.
2405 *
2406 * The @code element@ parameter specifies which value to get from 0 to
2407 * @code ippGetCount(attr)@ - 1.
2408 *
2409 * @since CUPS 1.6/macOS 10.8@
2410 */
2411
2412 int /* O - Lower value of range or 0 */
2413 ippGetRange(ipp_attribute_t *attr, /* I - IPP attribute */
2414 int element, /* I - Value number (0-based) */
2415 int *uppervalue)/* O - Upper value of range */
2416 {
2417 /*
2418 * Range check input...
2419 */
2420
2421 if (!attr || attr->value_tag != IPP_TAG_RANGE ||
2422 element < 0 || element >= attr->num_values)
2423 {
2424 if (uppervalue)
2425 *uppervalue = 0;
2426
2427 return (0);
2428 }
2429
2430 /*
2431 * Return the values...
2432 */
2433
2434 if (uppervalue)
2435 *uppervalue = attr->values[element].range.upper;
2436
2437 return (attr->values[element].range.lower);
2438 }
2439
2440
2441 /*
2442 * 'ippGetRequestId()' - Get the request ID from an IPP message.
2443 *
2444 * @since CUPS 1.6/macOS 10.8@
2445 */
2446
2447 int /* O - Request ID or 0 on error */
2448 ippGetRequestId(ipp_t *ipp) /* I - IPP message */
2449 {
2450 /*
2451 * Range check input...
2452 */
2453
2454 if (!ipp)
2455 return (0);
2456
2457 /*
2458 * Return the request ID...
2459 */
2460
2461 return (ipp->request.any.request_id);
2462 }
2463
2464
2465 /*
2466 * 'ippGetResolution()' - Get a resolution value for an attribute.
2467 *
2468 * The @code element@ parameter specifies which value to get from 0 to
2469 * @code ippGetCount(attr)@ - 1.
2470 *
2471 * @since CUPS 1.6/macOS 10.8@
2472 */
2473
2474 int /* O - Horizontal/cross feed resolution or 0 */
2475 ippGetResolution(
2476 ipp_attribute_t *attr, /* I - IPP attribute */
2477 int element, /* I - Value number (0-based) */
2478 int *yres, /* O - Vertical/feed resolution */
2479 ipp_res_t *units) /* O - Units for resolution */
2480 {
2481 /*
2482 * Range check input...
2483 */
2484
2485 if (!attr || attr->value_tag != IPP_TAG_RESOLUTION ||
2486 element < 0 || element >= attr->num_values)
2487 {
2488 if (yres)
2489 *yres = 0;
2490
2491 if (units)
2492 *units = (ipp_res_t)0;
2493
2494 return (0);
2495 }
2496
2497 /*
2498 * Return the value...
2499 */
2500
2501 if (yres)
2502 *yres = attr->values[element].resolution.yres;
2503
2504 if (units)
2505 *units = attr->values[element].resolution.units;
2506
2507 return (attr->values[element].resolution.xres);
2508 }
2509
2510
2511 /*
2512 * 'ippGetState()' - Get the IPP message state.
2513 *
2514 * @since CUPS 1.6/macOS 10.8@
2515 */
2516
2517 ipp_state_t /* O - IPP message state value */
2518 ippGetState(ipp_t *ipp) /* I - IPP message */
2519 {
2520 /*
2521 * Range check input...
2522 */
2523
2524 if (!ipp)
2525 return (IPP_STATE_IDLE);
2526
2527 /*
2528 * Return the value...
2529 */
2530
2531 return (ipp->state);
2532 }
2533
2534
2535 /*
2536 * 'ippGetStatusCode()' - Get the status code from an IPP response or event message.
2537 *
2538 * @since CUPS 1.6/macOS 10.8@
2539 */
2540
2541 ipp_status_t /* O - Status code in IPP message */
2542 ippGetStatusCode(ipp_t *ipp) /* I - IPP response or event message */
2543 {
2544 /*
2545 * Range check input...
2546 */
2547
2548 if (!ipp)
2549 return (IPP_STATUS_ERROR_INTERNAL);
2550
2551 /*
2552 * Return the value...
2553 */
2554
2555 return (ipp->request.status.status_code);
2556 }
2557
2558
2559 /*
2560 * 'ippGetString()' - Get the string and optionally the language code for an attribute.
2561 *
2562 * The @code element@ parameter specifies which value to get from 0 to
2563 * @code ippGetCount(attr)@ - 1.
2564 *
2565 * @since CUPS 1.6/macOS 10.8@
2566 */
2567
2568 const char *
2569 ippGetString(ipp_attribute_t *attr, /* I - IPP attribute */
2570 int element, /* I - Value number (0-based) */
2571 const char **language)/* O - Language code (@code NULL@ for don't care) */
2572 {
2573 ipp_tag_t tag; /* Value tag */
2574
2575
2576 /*
2577 * Range check input...
2578 */
2579
2580 tag = ippGetValueTag(attr);
2581
2582 if (!attr || element < 0 || element >= attr->num_values || (tag != IPP_TAG_TEXTLANG && tag != IPP_TAG_NAMELANG && (tag < IPP_TAG_TEXT || tag > IPP_TAG_MIMETYPE)))
2583 return (NULL);
2584
2585 /*
2586 * Return the value...
2587 */
2588
2589 if (language)
2590 *language = attr->values[element].string.language;
2591
2592 return (attr->values[element].string.text);
2593 }
2594
2595
2596 /*
2597 * 'ippGetValueTag()' - Get the value tag for an attribute.
2598 *
2599 * @since CUPS 1.6/macOS 10.8@
2600 */
2601
2602 ipp_tag_t /* O - Value tag or @code IPP_TAG_ZERO@ on error */
2603 ippGetValueTag(ipp_attribute_t *attr) /* I - IPP attribute */
2604 {
2605 /*
2606 * Range check input...
2607 */
2608
2609 if (!attr)
2610 return (IPP_TAG_ZERO);
2611
2612 /*
2613 * Return the value...
2614 */
2615
2616 return (attr->value_tag & IPP_TAG_CUPS_MASK);
2617 }
2618
2619
2620 /*
2621 * 'ippGetVersion()' - Get the major and minor version number from an IPP message.
2622 *
2623 * @since CUPS 1.6/macOS 10.8@
2624 */
2625
2626 int /* O - Major version number or 0 on error */
2627 ippGetVersion(ipp_t *ipp, /* I - IPP message */
2628 int *minor) /* O - Minor version number or @code NULL@ for don't care */
2629 {
2630 /*
2631 * Range check input...
2632 */
2633
2634 if (!ipp)
2635 {
2636 if (minor)
2637 *minor = 0;
2638
2639 return (0);
2640 }
2641
2642 /*
2643 * Return the value...
2644 */
2645
2646 if (minor)
2647 *minor = ipp->request.any.version[1];
2648
2649 return (ipp->request.any.version[0]);
2650 }
2651
2652
2653 /*
2654 * 'ippLength()' - Compute the length of an IPP message.
2655 */
2656
2657 size_t /* O - Size of IPP message */
2658 ippLength(ipp_t *ipp) /* I - IPP message */
2659 {
2660 return (ipp_length(ipp, 0));
2661 }
2662
2663
2664 /*
2665 * 'ippNextAttribute()' - Return the next attribute in the message.
2666 *
2667 * @since CUPS 1.6/macOS 10.8@
2668 */
2669
2670 ipp_attribute_t * /* O - Next attribute or @code NULL@ if none */
2671 ippNextAttribute(ipp_t *ipp) /* I - IPP message */
2672 {
2673 /*
2674 * Range check input...
2675 */
2676
2677 if (!ipp || !ipp->current)
2678 return (NULL);
2679
2680 /*
2681 * Return the next attribute...
2682 */
2683
2684 return (ipp->current = ipp->current->next);
2685 }
2686
2687
2688 /*
2689 * 'ippNew()' - Allocate a new IPP message.
2690 */
2691
2692 ipp_t * /* O - New IPP message */
2693 ippNew(void)
2694 {
2695 ipp_t *temp; /* New IPP message */
2696 _cups_globals_t *cg = _cupsGlobals();
2697 /* Global data */
2698
2699
2700 DEBUG_puts("ippNew()");
2701
2702 if ((temp = (ipp_t *)calloc(1, sizeof(ipp_t))) != NULL)
2703 {
2704 /*
2705 * Set default version - usually 2.0...
2706 */
2707
2708 if (cg->server_version == 0)
2709 _cupsSetDefaults();
2710
2711 temp->request.any.version[0] = (ipp_uchar_t)(cg->server_version / 10);
2712 temp->request.any.version[1] = (ipp_uchar_t)(cg->server_version % 10);
2713 temp->use = 1;
2714 }
2715
2716 DEBUG_printf(("1ippNew: Returning %p", (void *)temp));
2717
2718 return (temp);
2719 }
2720
2721
2722 /*
2723 * 'ippNewRequest()' - Allocate a new IPP request message.
2724 *
2725 * The new request message is initialized with the "attributes-charset" and
2726 * "attributes-natural-language" attributes added. The
2727 * "attributes-natural-language" value is derived from the current locale.
2728 *
2729 * @since CUPS 1.2/macOS 10.5@
2730 */
2731
2732 ipp_t * /* O - IPP request message */
2733 ippNewRequest(ipp_op_t op) /* I - Operation code */
2734 {
2735 ipp_t *request; /* IPP request message */
2736 cups_lang_t *language; /* Current language localization */
2737 static int request_id = 0; /* Current request ID */
2738 static _cups_mutex_t request_mutex = _CUPS_MUTEX_INITIALIZER;
2739 /* Mutex for request ID */
2740
2741
2742 DEBUG_printf(("ippNewRequest(op=%02x(%s))", op, ippOpString(op)));
2743
2744 /*
2745 * Create a new IPP message...
2746 */
2747
2748 if ((request = ippNew()) == NULL)
2749 return (NULL);
2750
2751 /*
2752 * Set the operation and request ID...
2753 */
2754
2755 _cupsMutexLock(&request_mutex);
2756
2757 request->request.op.operation_id = op;
2758 request->request.op.request_id = ++request_id;
2759
2760 _cupsMutexUnlock(&request_mutex);
2761
2762 /*
2763 * Use UTF-8 as the character set...
2764 */
2765
2766 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
2767 "attributes-charset", NULL, "utf-8");
2768
2769 /*
2770 * Get the language from the current locale...
2771 */
2772
2773 language = cupsLangDefault();
2774
2775 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
2776 "attributes-natural-language", NULL, language->language);
2777
2778 /*
2779 * Return the new request...
2780 */
2781
2782 return (request);
2783 }
2784
2785
2786 /*
2787 * 'ippNewResponse()' - Allocate a new IPP response message.
2788 *
2789 * The new response message is initialized with the same "version-number",
2790 * "request-id", "attributes-charset", and "attributes-natural-language" as the
2791 * provided request message. If the "attributes-charset" or
2792 * "attributes-natural-language" attributes are missing from the request,
2793 * 'utf-8' and a value derived from the current locale are substituted,
2794 * respectively.
2795 *
2796 * @since CUPS 1.7/macOS 10.9@
2797 */
2798
2799 ipp_t * /* O - IPP response message */
2800 ippNewResponse(ipp_t *request) /* I - IPP request message */
2801 {
2802 ipp_t *response; /* IPP response message */
2803 ipp_attribute_t *attr; /* Current attribute */
2804
2805
2806 /*
2807 * Range check input...
2808 */
2809
2810 if (!request)
2811 return (NULL);
2812
2813 /*
2814 * Create a new IPP message...
2815 */
2816
2817 if ((response = ippNew()) == NULL)
2818 return (NULL);
2819
2820 /*
2821 * Copy the request values over to the response...
2822 */
2823
2824 response->request.status.version[0] = request->request.op.version[0];
2825 response->request.status.version[1] = request->request.op.version[1];
2826 response->request.status.request_id = request->request.op.request_id;
2827
2828 /*
2829 * The first attribute MUST be attributes-charset...
2830 */
2831
2832 attr = request->attrs;
2833
2834 if (attr && attr->name && !strcmp(attr->name, "attributes-charset") &&
2835 attr->group_tag == IPP_TAG_OPERATION &&
2836 attr->value_tag == IPP_TAG_CHARSET &&
2837 attr->num_values == 1)
2838 {
2839 /*
2840 * Copy charset from request...
2841 */
2842
2843 ippAddString(response, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
2844 "attributes-charset", NULL, attr->values[0].string.text);
2845 }
2846 else
2847 {
2848 /*
2849 * Use "utf-8" as the default...
2850 */
2851
2852 ippAddString(response, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
2853 "attributes-charset", NULL, "utf-8");
2854 }
2855
2856 /*
2857 * Then attributes-natural-language...
2858 */
2859
2860 if (attr)
2861 attr = attr->next;
2862
2863 if (attr && attr->name &&
2864 !strcmp(attr->name, "attributes-natural-language") &&
2865 attr->group_tag == IPP_TAG_OPERATION &&
2866 attr->value_tag == IPP_TAG_LANGUAGE &&
2867 attr->num_values == 1)
2868 {
2869 /*
2870 * Copy language from request...
2871 */
2872
2873 ippAddString(response, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
2874 "attributes-natural-language", NULL,
2875 attr->values[0].string.text);
2876 }
2877 else
2878 {
2879 /*
2880 * Use the language from the current locale...
2881 */
2882
2883 cups_lang_t *language = cupsLangDefault();
2884 /* Current locale */
2885
2886 ippAddString(response, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
2887 "attributes-natural-language", NULL, language->language);
2888 }
2889
2890 return (response);
2891 }
2892
2893
2894 /*
2895 * 'ippRead()' - Read data for an IPP message from a HTTP connection.
2896 */
2897
2898 ipp_state_t /* O - Current state */
2899 ippRead(http_t *http, /* I - HTTP connection */
2900 ipp_t *ipp) /* I - IPP data */
2901 {
2902 DEBUG_printf(("ippRead(http=%p, ipp=%p), data_remaining=" CUPS_LLFMT, (void *)http, (void *)ipp, CUPS_LLCAST (http ? http->data_remaining : -1)));
2903
2904 if (!http)
2905 return (IPP_STATE_ERROR);
2906
2907 DEBUG_printf(("2ippRead: http->state=%d, http->used=%d", http->state, http->used));
2908
2909 return (ippReadIO(http, (ipp_iocb_t)ipp_read_http, http->blocking, NULL,
2910 ipp));
2911 }
2912
2913
2914 /*
2915 * 'ippReadFile()' - Read data for an IPP message from a file.
2916 *
2917 * @since CUPS 1.1.19/macOS 10.3@
2918 */
2919
2920 ipp_state_t /* O - Current state */
2921 ippReadFile(int fd, /* I - HTTP data */
2922 ipp_t *ipp) /* I - IPP data */
2923 {
2924 DEBUG_printf(("ippReadFile(fd=%d, ipp=%p)", fd, (void *)ipp));
2925
2926 return (ippReadIO(&fd, (ipp_iocb_t)ipp_read_file, 1, NULL, ipp));
2927 }
2928
2929
2930 /*
2931 * 'ippReadIO()' - Read data for an IPP message.
2932 *
2933 * @since CUPS 1.2/macOS 10.5@
2934 */
2935
2936 ipp_state_t /* O - Current state */
2937 ippReadIO(void *src, /* I - Data source */
2938 ipp_iocb_t cb, /* I - Read callback function */
2939 int blocking, /* I - Use blocking IO? */
2940 ipp_t *parent, /* I - Parent request, if any */
2941 ipp_t *ipp) /* I - IPP data */
2942 {
2943 int n; /* Length of data */
2944 unsigned char *buffer, /* Data buffer */
2945 string[IPP_MAX_TEXT],
2946 /* Small string buffer */
2947 *bufptr; /* Pointer into buffer */
2948 ipp_attribute_t *attr; /* Current attribute */
2949 ipp_tag_t tag; /* Current tag */
2950 ipp_tag_t value_tag; /* Current value tag */
2951 _ipp_value_t *value; /* Current value */
2952
2953
2954 DEBUG_printf(("ippReadIO(src=%p, cb=%p, blocking=%d, parent=%p, ipp=%p)", (void *)src, (void *)cb, blocking, (void *)parent, (void *)ipp));
2955 DEBUG_printf(("2ippReadIO: ipp->state=%d", ipp ? ipp->state : IPP_STATE_ERROR));
2956
2957 if (!src || !ipp)
2958 return (IPP_STATE_ERROR);
2959
2960 if ((buffer = (unsigned char *)_cupsBufferGet(IPP_BUF_SIZE)) == NULL)
2961 {
2962 DEBUG_puts("1ippReadIO: Unable to get read buffer.");
2963 return (IPP_STATE_ERROR);
2964 }
2965
2966 switch (ipp->state)
2967 {
2968 case IPP_STATE_IDLE :
2969 ipp->state ++; /* Avoid common problem... */
2970
2971 case IPP_STATE_HEADER :
2972 if (parent == NULL)
2973 {
2974 /*
2975 * Get the request header...
2976 */
2977
2978 if ((*cb)(src, buffer, 8) < 8)
2979 {
2980 DEBUG_puts("1ippReadIO: Unable to read header.");
2981 _cupsBufferRelease((char *)buffer);
2982 return (IPP_STATE_ERROR);
2983 }
2984
2985 /*
2986 * Then copy the request header over...
2987 */
2988
2989 ipp->request.any.version[0] = buffer[0];
2990 ipp->request.any.version[1] = buffer[1];
2991 ipp->request.any.op_status = (buffer[2] << 8) | buffer[3];
2992 ipp->request.any.request_id = (((((buffer[4] << 8) | buffer[5]) << 8) |
2993 buffer[6]) << 8) | buffer[7];
2994
2995 DEBUG_printf(("2ippReadIO: version=%d.%d", buffer[0], buffer[1]));
2996 DEBUG_printf(("2ippReadIO: op_status=%04x",
2997 ipp->request.any.op_status));
2998 DEBUG_printf(("2ippReadIO: request_id=%d",
2999 ipp->request.any.request_id));
3000 }
3001
3002 ipp->state = IPP_STATE_ATTRIBUTE;
3003 ipp->current = NULL;
3004 ipp->curtag = IPP_TAG_ZERO;
3005 ipp->prev = ipp->last;
3006
3007 /*
3008 * If blocking is disabled, stop here...
3009 */
3010
3011 if (!blocking)
3012 break;
3013
3014 case IPP_STATE_ATTRIBUTE :
3015 for (;;)
3016 {
3017 if ((*cb)(src, buffer, 1) < 1)
3018 {
3019 DEBUG_puts("1ippReadIO: Callback returned EOF/error");
3020 _cupsBufferRelease((char *)buffer);
3021 return (IPP_STATE_ERROR);
3022 }
3023
3024 DEBUG_printf(("2ippReadIO: ipp->current=%p, ipp->prev=%p", (void *)ipp->current, (void *)ipp->prev));
3025
3026 /*
3027 * Read this attribute...
3028 */
3029
3030 tag = (ipp_tag_t)buffer[0];
3031 if (tag == IPP_TAG_EXTENSION)
3032 {
3033 /*
3034 * Read 32-bit "extension" tag...
3035 */
3036
3037 if ((*cb)(src, buffer, 4) < 1)
3038 {
3039 DEBUG_puts("1ippReadIO: Callback returned EOF/error");
3040 _cupsBufferRelease((char *)buffer);
3041 return (IPP_STATE_ERROR);
3042 }
3043
3044 tag = (ipp_tag_t)((((((buffer[0] << 8) | buffer[1]) << 8) |
3045 buffer[2]) << 8) | buffer[3]);
3046
3047 if (tag & IPP_TAG_CUPS_CONST)
3048 {
3049 /*
3050 * Fail if the high bit is set in the tag...
3051 */
3052
3053 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP extension tag larger than 0x7FFFFFFF."), 1);
3054 DEBUG_printf(("1ippReadIO: bad tag 0x%x.", tag));
3055 _cupsBufferRelease((char *)buffer);
3056 return (IPP_STATE_ERROR);
3057 }
3058 }
3059
3060 if (tag == IPP_TAG_END)
3061 {
3062 /*
3063 * No more attributes left...
3064 */
3065
3066 DEBUG_puts("2ippReadIO: IPP_TAG_END.");
3067
3068 ipp->state = IPP_STATE_DATA;
3069 break;
3070 }
3071 else if (tag < IPP_TAG_UNSUPPORTED_VALUE)
3072 {
3073 /*
3074 * Group tag... Set the current group and continue...
3075 */
3076
3077 if (ipp->curtag == tag)
3078 ipp->prev = ippAddSeparator(ipp);
3079 else if (ipp->current)
3080 ipp->prev = ipp->current;
3081
3082 ipp->curtag = tag;
3083 ipp->current = NULL;
3084 DEBUG_printf(("2ippReadIO: group tag=%x(%s), ipp->prev=%p", tag, ippTagString(tag), (void *)ipp->prev));
3085 continue;
3086 }
3087
3088 DEBUG_printf(("2ippReadIO: value tag=%x(%s)", tag,
3089 ippTagString(tag)));
3090
3091 /*
3092 * Get the name...
3093 */
3094
3095 if ((*cb)(src, buffer, 2) < 2)
3096 {
3097 DEBUG_puts("1ippReadIO: unable to read name length.");
3098 _cupsBufferRelease((char *)buffer);
3099 return (IPP_STATE_ERROR);
3100 }
3101
3102 n = (buffer[0] << 8) | buffer[1];
3103
3104 if (n >= IPP_BUF_SIZE)
3105 {
3106 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP name larger than 32767 bytes."), 1);
3107 DEBUG_printf(("1ippReadIO: bad name length %d.", n));
3108 _cupsBufferRelease((char *)buffer);
3109 return (IPP_STATE_ERROR);
3110 }
3111
3112 DEBUG_printf(("2ippReadIO: name length=%d", n));
3113
3114 if (n == 0 && tag != IPP_TAG_MEMBERNAME &&
3115 tag != IPP_TAG_END_COLLECTION)
3116 {
3117 /*
3118 * More values for current attribute...
3119 */
3120
3121 if (ipp->current == NULL)
3122 {
3123 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP attribute has no name."), 1);
3124 DEBUG_puts("1ippReadIO: Attribute without name and no current.");
3125 _cupsBufferRelease((char *)buffer);
3126 return (IPP_STATE_ERROR);
3127 }
3128
3129 attr = ipp->current;
3130 value_tag = (ipp_tag_t)(attr->value_tag & IPP_TAG_CUPS_MASK);
3131
3132 /*
3133 * Make sure we aren't adding a new value of a different
3134 * type...
3135 */
3136
3137 if (value_tag == IPP_TAG_ZERO)
3138 {
3139 /*
3140 * Setting the value of a collection member...
3141 */
3142
3143 attr->value_tag = tag;
3144 }
3145 else if (value_tag == IPP_TAG_TEXTLANG ||
3146 value_tag == IPP_TAG_NAMELANG ||
3147 (value_tag >= IPP_TAG_TEXT &&
3148 value_tag <= IPP_TAG_MIMETYPE))
3149 {
3150 /*
3151 * String values can sometimes come across in different
3152 * forms; accept sets of differing values...
3153 */
3154
3155 if (tag != IPP_TAG_TEXTLANG && tag != IPP_TAG_NAMELANG &&
3156 (tag < IPP_TAG_TEXT || tag > IPP_TAG_MIMETYPE) &&
3157 tag != IPP_TAG_NOVALUE)
3158 {
3159 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3160 _("IPP 1setOf attribute with incompatible value "
3161 "tags."), 1);
3162 DEBUG_printf(("1ippReadIO: 1setOf value tag %x(%s) != %x(%s)",
3163 value_tag, ippTagString(value_tag), tag,
3164 ippTagString(tag)));
3165 _cupsBufferRelease((char *)buffer);
3166 return (IPP_STATE_ERROR);
3167 }
3168
3169 if (value_tag != tag)
3170 {
3171 DEBUG_printf(("1ippReadIO: Converting %s attribute from %s to %s.",
3172 attr->name, ippTagString(value_tag), ippTagString(tag)));
3173 ippSetValueTag(ipp, &attr, tag);
3174 }
3175 }
3176 else if (value_tag == IPP_TAG_INTEGER ||
3177 value_tag == IPP_TAG_RANGE)
3178 {
3179 /*
3180 * Integer and rangeOfInteger values can sometimes be mixed; accept
3181 * sets of differing values...
3182 */
3183
3184 if (tag != IPP_TAG_INTEGER && tag != IPP_TAG_RANGE)
3185 {
3186 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3187 _("IPP 1setOf attribute with incompatible value "
3188 "tags."), 1);
3189 DEBUG_printf(("1ippReadIO: 1setOf value tag %x(%s) != %x(%s)",
3190 value_tag, ippTagString(value_tag), tag,
3191 ippTagString(tag)));
3192 _cupsBufferRelease((char *)buffer);
3193 return (IPP_STATE_ERROR);
3194 }
3195
3196 if (value_tag == IPP_TAG_INTEGER && tag == IPP_TAG_RANGE)
3197 {
3198 /*
3199 * Convert integer values to rangeOfInteger values...
3200 */
3201
3202 DEBUG_printf(("1ippReadIO: Converting %s attribute to "
3203 "rangeOfInteger.", attr->name));
3204 ippSetValueTag(ipp, &attr, IPP_TAG_RANGE);
3205 }
3206 }
3207 else if (value_tag != tag)
3208 {
3209 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3210 _("IPP 1setOf attribute with incompatible value "
3211 "tags."), 1);
3212 DEBUG_printf(("1ippReadIO: value tag %x(%s) != %x(%s)",
3213 value_tag, ippTagString(value_tag), tag,
3214 ippTagString(tag)));
3215 _cupsBufferRelease((char *)buffer);
3216 return (IPP_STATE_ERROR);
3217 }
3218
3219 /*
3220 * Finally, reallocate the attribute array as needed...
3221 */
3222
3223 if ((value = ipp_set_value(ipp, &attr, attr->num_values)) == NULL)
3224 {
3225 _cupsBufferRelease((char *)buffer);
3226 return (IPP_STATE_ERROR);
3227 }
3228 }
3229 else if (tag == IPP_TAG_MEMBERNAME)
3230 {
3231 /*
3232 * Name must be length 0!
3233 */
3234
3235 if (n)
3236 {
3237 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP member name is not empty."), 1);
3238 DEBUG_puts("1ippReadIO: member name not empty.");
3239 _cupsBufferRelease((char *)buffer);
3240 return (IPP_STATE_ERROR);
3241 }
3242
3243 if (ipp->current)
3244 ipp->prev = ipp->current;
3245
3246 attr = ipp->current = ipp_add_attr(ipp, NULL, ipp->curtag, IPP_TAG_ZERO, 1);
3247 if (!attr)
3248 {
3249 _cupsSetHTTPError(HTTP_STATUS_ERROR);
3250 DEBUG_puts("1ippReadIO: unable to allocate attribute.");
3251 _cupsBufferRelease((char *)buffer);
3252 return (IPP_STATE_ERROR);
3253 }
3254
3255 DEBUG_printf(("2ippReadIO: membername, ipp->current=%p, ipp->prev=%p", (void *)ipp->current, (void *)ipp->prev));
3256
3257 value = attr->values;
3258 }
3259 else if (tag != IPP_TAG_END_COLLECTION)
3260 {
3261 /*
3262 * New attribute; read the name and add it...
3263 */
3264
3265 if ((*cb)(src, buffer, (size_t)n) < n)
3266 {
3267 DEBUG_puts("1ippReadIO: unable to read name.");
3268 _cupsBufferRelease((char *)buffer);
3269 return (IPP_STATE_ERROR);
3270 }
3271
3272 buffer[n] = '\0';
3273
3274 if (ipp->current)
3275 ipp->prev = ipp->current;
3276
3277 if ((attr = ipp->current = ipp_add_attr(ipp, (char *)buffer, ipp->curtag, tag,
3278 1)) == NULL)
3279 {
3280 _cupsSetHTTPError(HTTP_STATUS_ERROR);
3281 DEBUG_puts("1ippReadIO: unable to allocate attribute.");
3282 _cupsBufferRelease((char *)buffer);
3283 return (IPP_STATE_ERROR);
3284 }
3285
3286 DEBUG_printf(("2ippReadIO: name=\"%s\", ipp->current=%p, ipp->prev=%p", buffer, (void *)ipp->current, (void *)ipp->prev));
3287
3288 value = attr->values;
3289 }
3290 else
3291 {
3292 attr = NULL;
3293 value = NULL;
3294 }
3295
3296 if ((*cb)(src, buffer, 2) < 2)
3297 {
3298 DEBUG_puts("1ippReadIO: unable to read value length.");
3299 _cupsBufferRelease((char *)buffer);
3300 return (IPP_STATE_ERROR);
3301 }
3302
3303 n = (buffer[0] << 8) | buffer[1];
3304 DEBUG_printf(("2ippReadIO: value length=%d", n));
3305
3306 if (n >= IPP_BUF_SIZE)
3307 {
3308 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3309 _("IPP value larger than 32767 bytes."), 1);
3310 DEBUG_printf(("1ippReadIO: bad value length %d.", n));
3311 _cupsBufferRelease((char *)buffer);
3312 return (IPP_STATE_ERROR);
3313 }
3314
3315 switch (tag)
3316 {
3317 case IPP_TAG_INTEGER :
3318 case IPP_TAG_ENUM :
3319 if (n != 4)
3320 {
3321 if (tag == IPP_TAG_INTEGER)
3322 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3323 _("IPP integer value not 4 bytes."), 1);
3324 else
3325 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3326 _("IPP enum value not 4 bytes."), 1);
3327 DEBUG_printf(("1ippReadIO: bad integer value length %d.", n));
3328 _cupsBufferRelease((char *)buffer);
3329 return (IPP_STATE_ERROR);
3330 }
3331
3332 if ((*cb)(src, buffer, 4) < 4)
3333 {
3334 DEBUG_puts("1ippReadIO: Unable to read integer value.");
3335 _cupsBufferRelease((char *)buffer);
3336 return (IPP_STATE_ERROR);
3337 }
3338
3339 n = (((((buffer[0] << 8) | buffer[1]) << 8) | buffer[2]) << 8) |
3340 buffer[3];
3341
3342 if (attr->value_tag == IPP_TAG_RANGE)
3343 value->range.lower = value->range.upper = n;
3344 else
3345 value->integer = n;
3346 break;
3347
3348 case IPP_TAG_BOOLEAN :
3349 if (n != 1)
3350 {
3351 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP boolean value not 1 byte."),
3352 1);
3353 DEBUG_printf(("1ippReadIO: bad boolean value length %d.", n));
3354 _cupsBufferRelease((char *)buffer);
3355 return (IPP_STATE_ERROR);
3356 }
3357
3358 if ((*cb)(src, buffer, 1) < 1)
3359 {
3360 DEBUG_puts("1ippReadIO: Unable to read boolean value.");
3361 _cupsBufferRelease((char *)buffer);
3362 return (IPP_STATE_ERROR);
3363 }
3364
3365 value->boolean = (char)buffer[0];
3366 break;
3367
3368 case IPP_TAG_NOVALUE :
3369 case IPP_TAG_NOTSETTABLE :
3370 case IPP_TAG_DELETEATTR :
3371 case IPP_TAG_ADMINDEFINE :
3372 /*
3373 * These value types are not supposed to have values, however
3374 * some vendors (Brother) do not implement IPP correctly and so
3375 * we need to map non-empty values to text...
3376 */
3377
3378 if (attr->value_tag == tag)
3379 {
3380 if (n == 0)
3381 break;
3382
3383 attr->value_tag = IPP_TAG_TEXT;
3384 }
3385
3386 case IPP_TAG_TEXT :
3387 case IPP_TAG_NAME :
3388 case IPP_TAG_KEYWORD :
3389 case IPP_TAG_URI :
3390 case IPP_TAG_URISCHEME :
3391 case IPP_TAG_CHARSET :
3392 case IPP_TAG_LANGUAGE :
3393 case IPP_TAG_MIMETYPE :
3394 if (n > 0)
3395 {
3396 if ((*cb)(src, buffer, (size_t)n) < n)
3397 {
3398 DEBUG_puts("1ippReadIO: unable to read string value.");
3399 _cupsBufferRelease((char *)buffer);
3400 return (IPP_STATE_ERROR);
3401 }
3402 }
3403
3404 buffer[n] = '\0';
3405 value->string.text = _cupsStrAlloc((char *)buffer);
3406 DEBUG_printf(("2ippReadIO: value=\"%s\"", value->string.text));
3407 break;
3408
3409 case IPP_TAG_DATE :
3410 if (n != 11)
3411 {
3412 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("IPP date value not 11 bytes."), 1);
3413 DEBUG_printf(("1ippReadIO: bad date value length %d.", n));
3414 _cupsBufferRelease((char *)buffer);
3415 return (IPP_STATE_ERROR);
3416 }
3417
3418 if ((*cb)(src, value->date, 11) < 11)
3419 {
3420 DEBUG_puts("1ippReadIO: Unable to read date value.");
3421 _cupsBufferRelease((char *)buffer);
3422 return (IPP_STATE_ERROR);
3423 }
3424 break;
3425
3426 case IPP_TAG_RESOLUTION :
3427 if (n != 9)
3428 {
3429 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3430 _("IPP resolution value not 9 bytes."), 1);
3431 DEBUG_printf(("1ippReadIO: bad resolution value length %d.", n));
3432 _cupsBufferRelease((char *)buffer);
3433 return (IPP_STATE_ERROR);
3434 }
3435
3436 if ((*cb)(src, buffer, 9) < 9)
3437 {
3438 DEBUG_puts("1ippReadIO: Unable to read resolution value.");
3439 _cupsBufferRelease((char *)buffer);
3440 return (IPP_STATE_ERROR);
3441 }
3442
3443 value->resolution.xres =
3444 (((((buffer[0] << 8) | buffer[1]) << 8) | buffer[2]) << 8) |
3445 buffer[3];
3446 value->resolution.yres =
3447 (((((buffer[4] << 8) | buffer[5]) << 8) | buffer[6]) << 8) |
3448 buffer[7];
3449 value->resolution.units =
3450 (ipp_res_t)buffer[8];
3451 break;
3452
3453 case IPP_TAG_RANGE :
3454 if (n != 8)
3455 {
3456 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3457 _("IPP rangeOfInteger value not 8 bytes."), 1);
3458 DEBUG_printf(("1ippReadIO: bad rangeOfInteger value length "
3459 "%d.", n));
3460 _cupsBufferRelease((char *)buffer);
3461 return (IPP_STATE_ERROR);
3462 }
3463
3464 if ((*cb)(src, buffer, 8) < 8)
3465 {
3466 DEBUG_puts("1ippReadIO: Unable to read range value.");
3467 _cupsBufferRelease((char *)buffer);
3468 return (IPP_STATE_ERROR);
3469 }
3470
3471 value->range.lower =
3472 (((((buffer[0] << 8) | buffer[1]) << 8) | buffer[2]) << 8) |
3473 buffer[3];
3474 value->range.upper =
3475 (((((buffer[4] << 8) | buffer[5]) << 8) | buffer[6]) << 8) |
3476 buffer[7];
3477 break;
3478
3479 case IPP_TAG_TEXTLANG :
3480 case IPP_TAG_NAMELANG :
3481 if (n < 4)
3482 {
3483 if (tag == IPP_TAG_TEXTLANG)
3484 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3485 _("IPP textWithLanguage value less than "
3486 "minimum 4 bytes."), 1);
3487 else
3488 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3489 _("IPP nameWithLanguage value less than "
3490 "minimum 4 bytes."), 1);
3491 DEBUG_printf(("1ippReadIO: bad stringWithLanguage value "
3492 "length %d.", n));
3493 _cupsBufferRelease((char *)buffer);
3494 return (IPP_STATE_ERROR);
3495 }
3496
3497 if ((*cb)(src, buffer, (size_t)n) < n)
3498 {
3499 DEBUG_puts("1ippReadIO: Unable to read string w/language "
3500 "value.");
3501 _cupsBufferRelease((char *)buffer);
3502 return (IPP_STATE_ERROR);
3503 }
3504
3505 bufptr = buffer;
3506
3507 /*
3508 * text-with-language and name-with-language are composite
3509 * values:
3510 *
3511 * language-length
3512 * language
3513 * text-length
3514 * text
3515 */
3516
3517 n = (bufptr[0] << 8) | bufptr[1];
3518
3519 if ((bufptr + 2 + n) >= (buffer + IPP_BUF_SIZE) || n >= (int)sizeof(string))
3520 {
3521 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3522 _("IPP language length overflows value."), 1);
3523 DEBUG_printf(("1ippReadIO: bad language value length %d.",
3524 n));
3525 _cupsBufferRelease((char *)buffer);
3526 return (IPP_STATE_ERROR);
3527 }
3528 else if (n >= IPP_MAX_LANGUAGE)
3529 {
3530 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3531 _("IPP language length too large."), 1);
3532 DEBUG_printf(("1ippReadIO: bad language value length %d.",
3533 n));
3534 _cupsBufferRelease((char *)buffer);
3535 return (IPP_STATE_ERROR);
3536 }
3537
3538 memcpy(string, bufptr + 2, (size_t)n);
3539 string[n] = '\0';
3540
3541 value->string.language = _cupsStrAlloc((char *)string);
3542
3543 bufptr += 2 + n;
3544 n = (bufptr[0] << 8) | bufptr[1];
3545
3546 if ((bufptr + 2 + n) >= (buffer + IPP_BUF_SIZE))
3547 {
3548 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3549 _("IPP string length overflows value."), 1);
3550 DEBUG_printf(("1ippReadIO: bad string value length %d.", n));
3551 _cupsBufferRelease((char *)buffer);
3552 return (IPP_STATE_ERROR);
3553 }
3554
3555 bufptr[2 + n] = '\0';
3556 value->string.text = _cupsStrAlloc((char *)bufptr + 2);
3557 break;
3558
3559 case IPP_TAG_BEGIN_COLLECTION :
3560 /*
3561 * Oh, boy, here comes a collection value, so read it...
3562 */
3563
3564 value->collection = ippNew();
3565
3566 if (n > 0)
3567 {
3568 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3569 _("IPP begCollection value not 0 bytes."), 1);
3570 DEBUG_puts("1ippReadIO: begCollection tag with value length "
3571 "> 0.");
3572 _cupsBufferRelease((char *)buffer);
3573 return (IPP_STATE_ERROR);
3574 }
3575
3576 if (ippReadIO(src, cb, 1, ipp, value->collection) == IPP_STATE_ERROR)
3577 {
3578 DEBUG_puts("1ippReadIO: Unable to read collection value.");
3579 _cupsBufferRelease((char *)buffer);
3580 return (IPP_STATE_ERROR);
3581 }
3582 break;
3583
3584 case IPP_TAG_END_COLLECTION :
3585 _cupsBufferRelease((char *)buffer);
3586
3587 if (n > 0)
3588 {
3589 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3590 _("IPP endCollection value not 0 bytes."), 1);
3591 DEBUG_puts("1ippReadIO: endCollection tag with value length "
3592 "> 0.");
3593 return (IPP_STATE_ERROR);
3594 }
3595
3596 DEBUG_puts("1ippReadIO: endCollection tag...");
3597 return (ipp->state = IPP_STATE_DATA);
3598
3599 case IPP_TAG_MEMBERNAME :
3600 /*
3601 * The value the name of the member in the collection, which
3602 * we need to carry over...
3603 */
3604
3605 if (!attr)
3606 {
3607 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3608 _("IPP memberName with no attribute."), 1);
3609 DEBUG_puts("1ippReadIO: Member name without attribute.");
3610 _cupsBufferRelease((char *)buffer);
3611 return (IPP_STATE_ERROR);
3612 }
3613 else if (n == 0)
3614 {
3615 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3616 _("IPP memberName value is empty."), 1);
3617 DEBUG_puts("1ippReadIO: Empty member name value.");
3618 _cupsBufferRelease((char *)buffer);
3619 return (IPP_STATE_ERROR);
3620 }
3621 else if ((*cb)(src, buffer, (size_t)n) < n)
3622 {
3623 DEBUG_puts("1ippReadIO: Unable to read member name value.");
3624 _cupsBufferRelease((char *)buffer);
3625 return (IPP_STATE_ERROR);
3626 }
3627
3628 buffer[n] = '\0';
3629 attr->name = _cupsStrAlloc((char *)buffer);
3630
3631 /*
3632 * Since collection members are encoded differently than
3633 * regular attributes, make sure we don't start with an
3634 * empty value...
3635 */
3636
3637 attr->num_values --;
3638
3639 DEBUG_printf(("2ippReadIO: member name=\"%s\"", attr->name));
3640 break;
3641
3642 default : /* Other unsupported values */
3643 if (tag == IPP_TAG_STRING && n > IPP_MAX_LENGTH)
3644 {
3645 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
3646 _("IPP octetString length too large."), 1);
3647 DEBUG_printf(("1ippReadIO: bad octetString value length %d.",
3648 n));
3649 _cupsBufferRelease((char *)buffer);
3650 return (IPP_STATE_ERROR);
3651 }
3652
3653 value->unknown.length = n;
3654
3655 if (n > 0)
3656 {
3657 if ((value->unknown.data = malloc((size_t)n)) == NULL)
3658 {
3659 _cupsSetHTTPError(HTTP_STATUS_ERROR);
3660 DEBUG_puts("1ippReadIO: Unable to allocate value");
3661 _cupsBufferRelease((char *)buffer);
3662 return (IPP_STATE_ERROR);
3663 }
3664
3665 if ((*cb)(src, value->unknown.data, (size_t)n) < n)
3666 {
3667 DEBUG_puts("1ippReadIO: Unable to read unsupported value.");
3668 _cupsBufferRelease((char *)buffer);
3669 return (IPP_STATE_ERROR);
3670 }
3671 }
3672 else
3673 value->unknown.data = NULL;
3674 break;
3675 }
3676
3677 /*
3678 * If blocking is disabled, stop here...
3679 */
3680
3681 if (!blocking)
3682 break;
3683 }
3684 break;
3685
3686 case IPP_STATE_DATA :
3687 break;
3688
3689 default :
3690 break; /* anti-compiler-warning-code */
3691 }
3692
3693 DEBUG_printf(("1ippReadIO: returning ipp->state=%d.", ipp->state));
3694 _cupsBufferRelease((char *)buffer);
3695
3696 return (ipp->state);
3697 }
3698
3699
3700 /*
3701 * 'ippSetBoolean()' - Set a boolean value in an attribute.
3702 *
3703 * The @code ipp@ parameter refers to an IPP message previously created using
3704 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3705 *
3706 * The @code attr@ parameter may be modified as a result of setting the value.
3707 *
3708 * The @code element@ parameter specifies which value to set from 0 to
3709 * @code ippGetCount(attr)@.
3710 *
3711 * @since CUPS 1.6/macOS 10.8@
3712 */
3713
3714 int /* O - 1 on success, 0 on failure */
3715 ippSetBoolean(ipp_t *ipp, /* I - IPP message */
3716 ipp_attribute_t **attr, /* IO - IPP attribute */
3717 int element, /* I - Value number (0-based) */
3718 int boolvalue)/* I - Boolean value */
3719 {
3720 _ipp_value_t *value; /* Current value */
3721
3722
3723 /*
3724 * Range check input...
3725 */
3726
3727 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_BOOLEAN ||
3728 element < 0 || element > (*attr)->num_values)
3729 return (0);
3730
3731 /*
3732 * Set the value and return...
3733 */
3734
3735 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
3736 value->boolean = (char)boolvalue;
3737
3738 return (value != NULL);
3739 }
3740
3741
3742 /*
3743 * 'ippSetCollection()' - Set a collection value in an attribute.
3744 *
3745 * The @code ipp@ parameter refers to an IPP message previously created using
3746 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3747 *
3748 * The @code attr@ parameter may be modified as a result of setting the value.
3749 *
3750 * The @code element@ parameter specifies which value to set from 0 to
3751 * @code ippGetCount(attr)@.
3752 *
3753 * @since CUPS 1.6/macOS 10.8@
3754 */
3755
3756 int /* O - 1 on success, 0 on failure */
3757 ippSetCollection(
3758 ipp_t *ipp, /* I - IPP message */
3759 ipp_attribute_t **attr, /* IO - IPP attribute */
3760 int element, /* I - Value number (0-based) */
3761 ipp_t *colvalue) /* I - Collection value */
3762 {
3763 _ipp_value_t *value; /* Current value */
3764
3765
3766 /*
3767 * Range check input...
3768 */
3769
3770 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_BEGIN_COLLECTION ||
3771 element < 0 || element > (*attr)->num_values || !colvalue)
3772 return (0);
3773
3774 /*
3775 * Set the value and return...
3776 */
3777
3778 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
3779 {
3780 if (value->collection)
3781 ippDelete(value->collection);
3782
3783 value->collection = colvalue;
3784 colvalue->use ++;
3785 }
3786
3787 return (value != NULL);
3788 }
3789
3790
3791 /*
3792 * 'ippSetDate()' - Set a dateTime value in an attribute.
3793 *
3794 * The @code ipp@ parameter refers to an IPP message previously created using
3795 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3796 *
3797 * The @code attr@ parameter may be modified as a result of setting the value.
3798 *
3799 * The @code element@ parameter specifies which value to set from 0 to
3800 * @code ippGetCount(attr)@.
3801 *
3802 * @since CUPS 1.6/macOS 10.8@
3803 */
3804
3805 int /* O - 1 on success, 0 on failure */
3806 ippSetDate(ipp_t *ipp, /* I - IPP message */
3807 ipp_attribute_t **attr, /* IO - IPP attribute */
3808 int element, /* I - Value number (0-based) */
3809 const ipp_uchar_t *datevalue)/* I - dateTime value */
3810 {
3811 _ipp_value_t *value; /* Current value */
3812
3813
3814 /*
3815 * Range check input...
3816 */
3817
3818 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_DATE ||
3819 element < 0 || element > (*attr)->num_values || !datevalue)
3820 return (0);
3821
3822 /*
3823 * Set the value and return...
3824 */
3825
3826 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
3827 memcpy(value->date, datevalue, sizeof(value->date));
3828
3829 return (value != NULL);
3830 }
3831
3832
3833 /*
3834 * 'ippSetGroupTag()' - Set the group tag of an attribute.
3835 *
3836 * The @code ipp@ parameter refers to an IPP message previously created using
3837 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3838 *
3839 * The @code attr@ parameter may be modified as a result of setting the value.
3840 *
3841 * The @code group@ parameter specifies the IPP attribute group tag: none
3842 * (@code IPP_TAG_ZERO@, for member attributes), document (@code IPP_TAG_DOCUMENT@),
3843 * event notification (@code IPP_TAG_EVENT_NOTIFICATION@), operation
3844 * (@code IPP_TAG_OPERATION@), printer (@code IPP_TAG_PRINTER@), subscription
3845 * (@code IPP_TAG_SUBSCRIPTION@), or unsupported (@code IPP_TAG_UNSUPPORTED_GROUP@).
3846 *
3847 * @since CUPS 1.6/macOS 10.8@
3848 */
3849
3850 int /* O - 1 on success, 0 on failure */
3851 ippSetGroupTag(
3852 ipp_t *ipp, /* I - IPP message */
3853 ipp_attribute_t **attr, /* IO - Attribute */
3854 ipp_tag_t group_tag) /* I - Group tag */
3855 {
3856 /*
3857 * Range check input - group tag must be 0x01 to 0x0F, per RFC 8011...
3858 */
3859
3860 if (!ipp || !attr || !*attr ||
3861 group_tag < IPP_TAG_ZERO || group_tag == IPP_TAG_END ||
3862 group_tag >= IPP_TAG_UNSUPPORTED_VALUE)
3863 return (0);
3864
3865 /*
3866 * Set the group tag and return...
3867 */
3868
3869 (*attr)->group_tag = group_tag;
3870
3871 return (1);
3872 }
3873
3874
3875 /*
3876 * 'ippSetInteger()' - Set an integer or enum value in an attribute.
3877 *
3878 * The @code ipp@ parameter refers to an IPP message previously created using
3879 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3880 *
3881 * The @code attr@ parameter may be modified as a result of setting the value.
3882 *
3883 * The @code element@ parameter specifies which value to set from 0 to
3884 * @code ippGetCount(attr)@.
3885 *
3886 * @since CUPS 1.6/macOS 10.8@
3887 */
3888
3889 int /* O - 1 on success, 0 on failure */
3890 ippSetInteger(ipp_t *ipp, /* I - IPP message */
3891 ipp_attribute_t **attr, /* IO - IPP attribute */
3892 int element, /* I - Value number (0-based) */
3893 int intvalue) /* I - Integer/enum value */
3894 {
3895 _ipp_value_t *value; /* Current value */
3896
3897
3898 /*
3899 * Range check input...
3900 */
3901
3902 if (!ipp || !attr || !*attr ||
3903 ((*attr)->value_tag != IPP_TAG_INTEGER && (*attr)->value_tag != IPP_TAG_ENUM) ||
3904 element < 0 || element > (*attr)->num_values)
3905 return (0);
3906
3907 /*
3908 * Set the value and return...
3909 */
3910
3911 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
3912 value->integer = intvalue;
3913
3914 return (value != NULL);
3915 }
3916
3917
3918 /*
3919 * 'ippSetName()' - Set the name of an attribute.
3920 *
3921 * The @code ipp@ parameter refers to an IPP message previously created using
3922 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3923 *
3924 * The @code attr@ parameter may be modified as a result of setting the value.
3925 *
3926 * @since CUPS 1.6/macOS 10.8@
3927 */
3928
3929 int /* O - 1 on success, 0 on failure */
3930 ippSetName(ipp_t *ipp, /* I - IPP message */
3931 ipp_attribute_t **attr, /* IO - IPP attribute */
3932 const char *name) /* I - Attribute name */
3933 {
3934 char *temp; /* Temporary name value */
3935
3936
3937 /*
3938 * Range check input...
3939 */
3940
3941 if (!ipp || !attr || !*attr)
3942 return (0);
3943
3944 /*
3945 * Set the value and return...
3946 */
3947
3948 if ((temp = _cupsStrAlloc(name)) != NULL)
3949 {
3950 if ((*attr)->name)
3951 _cupsStrFree((*attr)->name);
3952
3953 (*attr)->name = temp;
3954 }
3955
3956 return (temp != NULL);
3957 }
3958
3959
3960 /*
3961 * 'ippSetOctetString()' - Set an octetString value in an IPP attribute.
3962 *
3963 * The @code ipp@ parameter refers to an IPP message previously created using
3964 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
3965 *
3966 * The @code attr@ parameter may be modified as a result of setting the value.
3967 *
3968 * The @code element@ parameter specifies which value to set from 0 to
3969 * @code ippGetCount(attr)@.
3970 *
3971 * @since CUPS 1.7/macOS 10.9@
3972 */
3973
3974 int /* O - 1 on success, 0 on failure */
3975 ippSetOctetString(
3976 ipp_t *ipp, /* I - IPP message */
3977 ipp_attribute_t **attr, /* IO - IPP attribute */
3978 int element, /* I - Value number (0-based) */
3979 const void *data, /* I - Pointer to octetString data */
3980 int datalen) /* I - Length of octetString data */
3981 {
3982 _ipp_value_t *value; /* Current value */
3983
3984
3985 /*
3986 * Range check input...
3987 */
3988
3989 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_STRING ||
3990 element < 0 || element > (*attr)->num_values ||
3991 datalen < 0 || datalen > IPP_MAX_LENGTH)
3992 return (0);
3993
3994 /*
3995 * Set the value and return...
3996 */
3997
3998 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
3999 {
4000 if ((int)((*attr)->value_tag) & IPP_TAG_CUPS_CONST)
4001 {
4002 /*
4003 * Just copy the pointer...
4004 */
4005
4006 value->unknown.data = (void *)data;
4007 value->unknown.length = datalen;
4008 }
4009 else
4010 {
4011 /*
4012 * Copy the data...
4013 */
4014
4015 if (value->unknown.data)
4016 {
4017 /*
4018 * Free previous data...
4019 */
4020
4021 free(value->unknown.data);
4022
4023 value->unknown.data = NULL;
4024 value->unknown.length = 0;
4025 }
4026
4027 if (datalen > 0)
4028 {
4029 void *temp; /* Temporary data pointer */
4030
4031 if ((temp = malloc((size_t)datalen)) != NULL)
4032 {
4033 memcpy(temp, data, (size_t)datalen);
4034
4035 value->unknown.data = temp;
4036 value->unknown.length = datalen;
4037 }
4038 else
4039 return (0);
4040 }
4041 }
4042 }
4043
4044 return (value != NULL);
4045 }
4046
4047
4048 /*
4049 * 'ippSetOperation()' - Set the operation ID in an IPP request message.
4050 *
4051 * The @code ipp@ parameter refers to an IPP message previously created using
4052 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4053 *
4054 * @since CUPS 1.6/macOS 10.8@
4055 */
4056
4057 int /* O - 1 on success, 0 on failure */
4058 ippSetOperation(ipp_t *ipp, /* I - IPP request message */
4059 ipp_op_t op) /* I - Operation ID */
4060 {
4061 /*
4062 * Range check input...
4063 */
4064
4065 if (!ipp)
4066 return (0);
4067
4068 /*
4069 * Set the operation and return...
4070 */
4071
4072 ipp->request.op.operation_id = op;
4073
4074 return (1);
4075 }
4076
4077
4078 /*
4079 * 'ippSetRange()' - Set a rangeOfInteger value in an attribute.
4080 *
4081 * The @code ipp@ parameter refers to an IPP message previously created using
4082 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4083 *
4084 * The @code attr@ parameter may be modified as a result of setting the value.
4085 *
4086 * The @code element@ parameter specifies which value to set from 0 to
4087 * @code ippGetCount(attr)@.
4088 *
4089 * @since CUPS 1.6/macOS 10.8@
4090 */
4091
4092 int /* O - 1 on success, 0 on failure */
4093 ippSetRange(ipp_t *ipp, /* I - IPP message */
4094 ipp_attribute_t **attr, /* IO - IPP attribute */
4095 int element, /* I - Value number (0-based) */
4096 int lowervalue, /* I - Lower bound for range */
4097 int uppervalue) /* I - Upper bound for range */
4098 {
4099 _ipp_value_t *value; /* Current value */
4100
4101
4102 /*
4103 * Range check input...
4104 */
4105
4106 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_RANGE ||
4107 element < 0 || element > (*attr)->num_values || lowervalue > uppervalue)
4108 return (0);
4109
4110 /*
4111 * Set the value and return...
4112 */
4113
4114 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
4115 {
4116 value->range.lower = lowervalue;
4117 value->range.upper = uppervalue;
4118 }
4119
4120 return (value != NULL);
4121 }
4122
4123
4124 /*
4125 * 'ippSetRequestId()' - Set the request ID in an IPP message.
4126 *
4127 * The @code ipp@ parameter refers to an IPP message previously created using
4128 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4129 *
4130 * The @code request_id@ parameter must be greater than 0.
4131 *
4132 * @since CUPS 1.6/macOS 10.8@
4133 */
4134
4135 int /* O - 1 on success, 0 on failure */
4136 ippSetRequestId(ipp_t *ipp, /* I - IPP message */
4137 int request_id) /* I - Request ID */
4138 {
4139 /*
4140 * Range check input; not checking request_id values since ipptool wants to send
4141 * invalid values for conformance testing and a bad request_id does not affect the
4142 * encoding of a message...
4143 */
4144
4145 if (!ipp)
4146 return (0);
4147
4148 /*
4149 * Set the request ID and return...
4150 */
4151
4152 ipp->request.any.request_id = request_id;
4153
4154 return (1);
4155 }
4156
4157
4158 /*
4159 * 'ippSetResolution()' - Set a resolution value in an attribute.
4160 *
4161 * The @code ipp@ parameter refers to an IPP message previously created using
4162 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4163 *
4164 * The @code attr@ parameter may be modified as a result of setting the value.
4165 *
4166 * The @code element@ parameter specifies which value to set from 0 to
4167 * @code ippGetCount(attr)@.
4168 *
4169 * @since CUPS 1.6/macOS 10.8@
4170 */
4171
4172 int /* O - 1 on success, 0 on failure */
4173 ippSetResolution(
4174 ipp_t *ipp, /* I - IPP message */
4175 ipp_attribute_t **attr, /* IO - IPP attribute */
4176 int element, /* I - Value number (0-based) */
4177 ipp_res_t unitsvalue, /* I - Resolution units */
4178 int xresvalue, /* I - Horizontal/cross feed resolution */
4179 int yresvalue) /* I - Vertical/feed resolution */
4180 {
4181 _ipp_value_t *value; /* Current value */
4182
4183
4184 /*
4185 * Range check input...
4186 */
4187
4188 if (!ipp || !attr || !*attr || (*attr)->value_tag != IPP_TAG_RESOLUTION ||
4189 element < 0 || element > (*attr)->num_values || xresvalue <= 0 || yresvalue <= 0 ||
4190 unitsvalue < IPP_RES_PER_INCH || unitsvalue > IPP_RES_PER_CM)
4191 return (0);
4192
4193 /*
4194 * Set the value and return...
4195 */
4196
4197 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
4198 {
4199 value->resolution.units = unitsvalue;
4200 value->resolution.xres = xresvalue;
4201 value->resolution.yres = yresvalue;
4202 }
4203
4204 return (value != NULL);
4205 }
4206
4207
4208 /*
4209 * 'ippSetState()' - Set the current state of the IPP message.
4210 *
4211 * @since CUPS 1.6/macOS 10.8@
4212 */
4213
4214 int /* O - 1 on success, 0 on failure */
4215 ippSetState(ipp_t *ipp, /* I - IPP message */
4216 ipp_state_t state) /* I - IPP state value */
4217 {
4218 /*
4219 * Range check input...
4220 */
4221
4222 if (!ipp)
4223 return (0);
4224
4225 /*
4226 * Set the state and return...
4227 */
4228
4229 ipp->state = state;
4230 ipp->current = NULL;
4231
4232 return (1);
4233 }
4234
4235
4236 /*
4237 * 'ippSetStatusCode()' - Set the status code in an IPP response or event message.
4238 *
4239 * The @code ipp@ parameter refers to an IPP message previously created using
4240 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4241 *
4242 * @since CUPS 1.6/macOS 10.8@
4243 */
4244
4245 int /* O - 1 on success, 0 on failure */
4246 ippSetStatusCode(ipp_t *ipp, /* I - IPP response or event message */
4247 ipp_status_t status) /* I - Status code */
4248 {
4249 /*
4250 * Range check input...
4251 */
4252
4253 if (!ipp)
4254 return (0);
4255
4256 /*
4257 * Set the status code and return...
4258 */
4259
4260 ipp->request.status.status_code = status;
4261
4262 return (1);
4263 }
4264
4265
4266 /*
4267 * 'ippSetString()' - Set a string value in an attribute.
4268 *
4269 * The @code ipp@ parameter refers to an IPP message previously created using
4270 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4271 *
4272 * The @code attr@ parameter may be modified as a result of setting the value.
4273 *
4274 * The @code element@ parameter specifies which value to set from 0 to
4275 * @code ippGetCount(attr)@.
4276 *
4277 * @since CUPS 1.6/macOS 10.8@
4278 */
4279
4280 int /* O - 1 on success, 0 on failure */
4281 ippSetString(ipp_t *ipp, /* I - IPP message */
4282 ipp_attribute_t **attr, /* IO - IPP attribute */
4283 int element, /* I - Value number (0-based) */
4284 const char *strvalue) /* I - String value */
4285 {
4286 char *temp; /* Temporary string */
4287 _ipp_value_t *value; /* Current value */
4288
4289
4290 /*
4291 * Range check input...
4292 */
4293
4294 if (!ipp || !attr || !*attr ||
4295 ((*attr)->value_tag != IPP_TAG_TEXTLANG &&
4296 (*attr)->value_tag != IPP_TAG_NAMELANG &&
4297 ((*attr)->value_tag < IPP_TAG_TEXT ||
4298 (*attr)->value_tag > IPP_TAG_MIMETYPE)) ||
4299 element < 0 || element > (*attr)->num_values || !strvalue)
4300 return (0);
4301
4302 /*
4303 * Set the value and return...
4304 */
4305
4306 if ((value = ipp_set_value(ipp, attr, element)) != NULL)
4307 {
4308 if (element > 0)
4309 value->string.language = (*attr)->values[0].string.language;
4310
4311 if ((int)((*attr)->value_tag) & IPP_TAG_CUPS_CONST)
4312 value->string.text = (char *)strvalue;
4313 else if ((temp = _cupsStrAlloc(strvalue)) != NULL)
4314 {
4315 if (value->string.text)
4316 _cupsStrFree(value->string.text);
4317
4318 value->string.text = temp;
4319 }
4320 else
4321 return (0);
4322 }
4323
4324 return (value != NULL);
4325 }
4326
4327
4328 /*
4329 * 'ippSetStringf()' - Set a formatted string value of an attribute.
4330 *
4331 * The @code ipp@ parameter refers to an IPP message previously created using
4332 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4333 *
4334 * The @code attr@ parameter may be modified as a result of setting the value.
4335 *
4336 * The @code element@ parameter specifies which value to set from 0 to
4337 * @code ippGetCount(attr)@.
4338 *
4339 * The @code format@ parameter uses formatting characters compatible with the
4340 * printf family of standard functions. Additional arguments follow it as
4341 * needed. The formatted string is truncated as needed to the maximum length of
4342 * the corresponding value type.
4343 *
4344 * @since CUPS 1.7/macOS 10.9@
4345 */
4346
4347 int /* O - 1 on success, 0 on failure */
4348 ippSetStringf(ipp_t *ipp, /* I - IPP message */
4349 ipp_attribute_t **attr, /* IO - IPP attribute */
4350 int element, /* I - Value number (0-based) */
4351 const char *format, /* I - Printf-style format string */
4352 ...) /* I - Additional arguments as needed */
4353 {
4354 int ret; /* Return value */
4355 va_list ap; /* Pointer to additional arguments */
4356
4357
4358 va_start(ap, format);
4359 ret = ippSetStringfv(ipp, attr, element, format, ap);
4360 va_end(ap);
4361
4362 return (ret);
4363 }
4364
4365
4366 /*
4367 * 'ippSetStringf()' - Set a formatted string value of an attribute.
4368 *
4369 * The @code ipp@ parameter refers to an IPP message previously created using
4370 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4371 *
4372 * The @code attr@ parameter may be modified as a result of setting the value.
4373 *
4374 * The @code element@ parameter specifies which value to set from 0 to
4375 * @code ippGetCount(attr)@.
4376 *
4377 * The @code format@ parameter uses formatting characters compatible with the
4378 * printf family of standard functions. Additional arguments follow it as
4379 * needed. The formatted string is truncated as needed to the maximum length of
4380 * the corresponding value type.
4381 *
4382 * @since CUPS 1.7/macOS 10.9@
4383 */
4384
4385 int /* O - 1 on success, 0 on failure */
4386 ippSetStringfv(ipp_t *ipp, /* I - IPP message */
4387 ipp_attribute_t **attr, /* IO - IPP attribute */
4388 int element, /* I - Value number (0-based) */
4389 const char *format, /* I - Printf-style format string */
4390 va_list ap) /* I - Pointer to additional arguments */
4391 {
4392 ipp_tag_t value_tag; /* Value tag */
4393 char buffer[IPP_MAX_TEXT + 4];
4394 /* Formatted text string */
4395 ssize_t bytes, /* Length of formatted value */
4396 max_bytes; /* Maximum number of bytes for value */
4397
4398
4399 /*
4400 * Range check input...
4401 */
4402
4403 if (attr && *attr)
4404 value_tag = (*attr)->value_tag & IPP_TAG_CUPS_MASK;
4405 else
4406 value_tag = IPP_TAG_ZERO;
4407
4408 if (!ipp || !attr || !*attr ||
4409 (value_tag < IPP_TAG_TEXT && value_tag != IPP_TAG_TEXTLANG &&
4410 value_tag != IPP_TAG_NAMELANG) || value_tag > IPP_TAG_MIMETYPE ||
4411 !format)
4412 return (0);
4413
4414 /*
4415 * Format the string...
4416 */
4417
4418 if (!strcmp(format, "%s"))
4419 {
4420 /*
4421 * Optimize the simple case...
4422 */
4423
4424 const char *s = va_arg(ap, char *);
4425
4426 if (!s)
4427 s = "(null)";
4428
4429 bytes = (ssize_t)strlen(s);
4430 strlcpy(buffer, s, sizeof(buffer));
4431 }
4432 else
4433 {
4434 /*
4435 * Do a full formatting of the message...
4436 */
4437
4438 if ((bytes = vsnprintf(buffer, sizeof(buffer), format, ap)) < 0)
4439 return (0);
4440 }
4441
4442 /*
4443 * Limit the length of the string...
4444 */
4445
4446 switch (value_tag)
4447 {
4448 default :
4449 case IPP_TAG_TEXT :
4450 case IPP_TAG_TEXTLANG :
4451 max_bytes = IPP_MAX_TEXT;
4452 break;
4453
4454 case IPP_TAG_NAME :
4455 case IPP_TAG_NAMELANG :
4456 max_bytes = IPP_MAX_NAME;
4457 break;
4458
4459 case IPP_TAG_CHARSET :
4460 max_bytes = IPP_MAX_CHARSET;
4461 break;
4462
4463 case IPP_TAG_KEYWORD :
4464 max_bytes = IPP_MAX_KEYWORD;
4465 break;
4466
4467 case IPP_TAG_LANGUAGE :
4468 max_bytes = IPP_MAX_LANGUAGE;
4469 break;
4470
4471 case IPP_TAG_MIMETYPE :
4472 max_bytes = IPP_MAX_MIMETYPE;
4473 break;
4474
4475 case IPP_TAG_URI :
4476 max_bytes = IPP_MAX_URI;
4477 break;
4478
4479 case IPP_TAG_URISCHEME :
4480 max_bytes = IPP_MAX_URISCHEME;
4481 break;
4482 }
4483
4484 if (bytes >= max_bytes)
4485 {
4486 char *bufmax, /* Buffer at max_bytes */
4487 *bufptr; /* Pointer into buffer */
4488
4489 bufptr = buffer + strlen(buffer) - 1;
4490 bufmax = buffer + max_bytes - 1;
4491
4492 while (bufptr > bufmax)
4493 {
4494 if (*bufptr & 0x80)
4495 {
4496 while ((*bufptr & 0xc0) == 0x80 && bufptr > buffer)
4497 bufptr --;
4498 }
4499
4500 bufptr --;
4501 }
4502
4503 *bufptr = '\0';
4504 }
4505
4506 /*
4507 * Set the formatted string and return...
4508 */
4509
4510 return (ippSetString(ipp, attr, element, buffer));
4511 }
4512
4513
4514 /*
4515 * 'ippSetValueTag()' - Set the value tag of an attribute.
4516 *
4517 * The @code ipp@ parameter refers to an IPP message previously created using
4518 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4519 *
4520 * The @code attr@ parameter may be modified as a result of setting the value.
4521 *
4522 * Integer (@code IPP_TAG_INTEGER@) values can be promoted to rangeOfInteger
4523 * (@code IPP_TAG_RANGE@) values, the various string tags can be promoted to name
4524 * (@code IPP_TAG_NAME@) or nameWithLanguage (@code IPP_TAG_NAMELANG@) values, text
4525 * (@code IPP_TAG_TEXT@) values can be promoted to textWithLanguage
4526 * (@code IPP_TAG_TEXTLANG@) values, and all values can be demoted to the various
4527 * out-of-band value tags such as no-value (@code IPP_TAG_NOVALUE@). All other changes
4528 * will be rejected.
4529 *
4530 * Promoting a string attribute to nameWithLanguage or textWithLanguage adds the language
4531 * code in the "attributes-natural-language" attribute or, if not present, the language
4532 * code for the current locale.
4533 *
4534 * @since CUPS 1.6/macOS 10.8@
4535 */
4536
4537 int /* O - 1 on success, 0 on failure */
4538 ippSetValueTag(
4539 ipp_t *ipp, /* I - IPP message */
4540 ipp_attribute_t **attr, /* IO - IPP attribute */
4541 ipp_tag_t value_tag) /* I - Value tag */
4542 {
4543 int i; /* Looping var */
4544 _ipp_value_t *value; /* Current value */
4545 int integer; /* Current integer value */
4546 cups_lang_t *language; /* Current language */
4547 char code[32]; /* Language code */
4548 ipp_tag_t temp_tag; /* Temporary value tag */
4549
4550
4551 /*
4552 * Range check input...
4553 */
4554
4555 if (!ipp || !attr || !*attr)
4556 return (0);
4557
4558 /*
4559 * If there is no change, return immediately...
4560 */
4561
4562 if (value_tag == (*attr)->value_tag)
4563 return (1);
4564
4565 /*
4566 * Otherwise implement changes as needed...
4567 */
4568
4569 temp_tag = (ipp_tag_t)((int)((*attr)->value_tag) & IPP_TAG_CUPS_MASK);
4570
4571 switch (value_tag)
4572 {
4573 case IPP_TAG_UNSUPPORTED_VALUE :
4574 case IPP_TAG_DEFAULT :
4575 case IPP_TAG_UNKNOWN :
4576 case IPP_TAG_NOVALUE :
4577 case IPP_TAG_NOTSETTABLE :
4578 case IPP_TAG_DELETEATTR :
4579 case IPP_TAG_ADMINDEFINE :
4580 /*
4581 * Free any existing values...
4582 */
4583
4584 if ((*attr)->num_values > 0)
4585 ipp_free_values(*attr, 0, (*attr)->num_values);
4586
4587 /*
4588 * Set out-of-band value...
4589 */
4590
4591 (*attr)->value_tag = value_tag;
4592 break;
4593
4594 case IPP_TAG_RANGE :
4595 if (temp_tag != IPP_TAG_INTEGER)
4596 return (0);
4597
4598 for (i = (*attr)->num_values, value = (*attr)->values;
4599 i > 0;
4600 i --, value ++)
4601 {
4602 integer = value->integer;
4603 value->range.lower = value->range.upper = integer;
4604 }
4605
4606 (*attr)->value_tag = IPP_TAG_RANGE;
4607 break;
4608
4609 case IPP_TAG_NAME :
4610 if (temp_tag != IPP_TAG_KEYWORD && temp_tag != IPP_TAG_URI &&
4611 temp_tag != IPP_TAG_URISCHEME && temp_tag != IPP_TAG_LANGUAGE &&
4612 temp_tag != IPP_TAG_MIMETYPE)
4613 return (0);
4614
4615 (*attr)->value_tag = (ipp_tag_t)(IPP_TAG_NAME | ((*attr)->value_tag & IPP_TAG_CUPS_CONST));
4616 break;
4617
4618 case IPP_TAG_NAMELANG :
4619 case IPP_TAG_TEXTLANG :
4620 if (value_tag == IPP_TAG_NAMELANG &&
4621 (temp_tag != IPP_TAG_NAME && temp_tag != IPP_TAG_KEYWORD &&
4622 temp_tag != IPP_TAG_URI && temp_tag != IPP_TAG_URISCHEME &&
4623 temp_tag != IPP_TAG_LANGUAGE && temp_tag != IPP_TAG_MIMETYPE))
4624 return (0);
4625
4626 if (value_tag == IPP_TAG_TEXTLANG && temp_tag != IPP_TAG_TEXT)
4627 return (0);
4628
4629 if (ipp->attrs && ipp->attrs->next && ipp->attrs->next->name &&
4630 !strcmp(ipp->attrs->next->name, "attributes-natural-language"))
4631 {
4632 /*
4633 * Use the language code from the IPP message...
4634 */
4635
4636 (*attr)->values[0].string.language =
4637 _cupsStrAlloc(ipp->attrs->next->values[0].string.text);
4638 }
4639 else
4640 {
4641 /*
4642 * Otherwise, use the language code corresponding to the locale...
4643 */
4644
4645 language = cupsLangDefault();
4646 (*attr)->values[0].string.language = _cupsStrAlloc(ipp_lang_code(language->language,
4647 code,
4648 sizeof(code)));
4649 }
4650
4651 for (i = (*attr)->num_values - 1, value = (*attr)->values + 1;
4652 i > 0;
4653 i --, value ++)
4654 value->string.language = (*attr)->values[0].string.language;
4655
4656 if ((int)(*attr)->value_tag & IPP_TAG_CUPS_CONST)
4657 {
4658 /*
4659 * Make copies of all values...
4660 */
4661
4662 for (i = (*attr)->num_values, value = (*attr)->values;
4663 i > 0;
4664 i --, value ++)
4665 value->string.text = _cupsStrAlloc(value->string.text);
4666 }
4667
4668 (*attr)->value_tag = IPP_TAG_NAMELANG;
4669 break;
4670
4671 case IPP_TAG_KEYWORD :
4672 if (temp_tag == IPP_TAG_NAME || temp_tag == IPP_TAG_NAMELANG)
4673 break; /* Silently "allow" name -> keyword */
4674
4675 default :
4676 return (0);
4677 }
4678
4679 return (1);
4680 }
4681
4682
4683 /*
4684 * 'ippSetVersion()' - Set the version number in an IPP message.
4685 *
4686 * The @code ipp@ parameter refers to an IPP message previously created using
4687 * the @link ippNew@, @link ippNewRequest@, or @link ippNewResponse@ functions.
4688 *
4689 * The valid version numbers are currently 1.0, 1.1, 2.0, 2.1, and 2.2.
4690 *
4691 * @since CUPS 1.6/macOS 10.8@
4692 */
4693
4694 int /* O - 1 on success, 0 on failure */
4695 ippSetVersion(ipp_t *ipp, /* I - IPP message */
4696 int major, /* I - Major version number (major.minor) */
4697 int minor) /* I - Minor version number (major.minor) */
4698 {
4699 /*
4700 * Range check input...
4701 */
4702
4703 if (!ipp || major < 0 || minor < 0)
4704 return (0);
4705
4706 /*
4707 * Set the version number...
4708 */
4709
4710 ipp->request.any.version[0] = (ipp_uchar_t)major;
4711 ipp->request.any.version[1] = (ipp_uchar_t)minor;
4712
4713 return (1);
4714 }
4715
4716
4717 /*
4718 * 'ippTimeToDate()' - Convert from time in seconds to RFC 2579 format.
4719 */
4720
4721 const ipp_uchar_t * /* O - RFC-2579 date/time data */
4722 ippTimeToDate(time_t t) /* I - Time in seconds */
4723 {
4724 struct tm *unixdate; /* UNIX unixdate/time info */
4725 ipp_uchar_t *date = _cupsGlobals()->ipp_date;
4726 /* RFC-2579 date/time data */
4727
4728
4729 /*
4730 * RFC-2579 date/time format is:
4731 *
4732 * Byte(s) Description
4733 * ------- -----------
4734 * 0-1 Year (0 to 65535)
4735 * 2 Month (1 to 12)
4736 * 3 Day (1 to 31)
4737 * 4 Hours (0 to 23)
4738 * 5 Minutes (0 to 59)
4739 * 6 Seconds (0 to 60, 60 = "leap second")
4740 * 7 Deciseconds (0 to 9)
4741 * 8 +/- UTC
4742 * 9 UTC hours (0 to 11)
4743 * 10 UTC minutes (0 to 59)
4744 */
4745
4746 unixdate = gmtime(&t);
4747 unixdate->tm_year += 1900;
4748
4749 date[0] = (ipp_uchar_t)(unixdate->tm_year >> 8);
4750 date[1] = (ipp_uchar_t)(unixdate->tm_year);
4751 date[2] = (ipp_uchar_t)(unixdate->tm_mon + 1);
4752 date[3] = (ipp_uchar_t)unixdate->tm_mday;
4753 date[4] = (ipp_uchar_t)unixdate->tm_hour;
4754 date[5] = (ipp_uchar_t)unixdate->tm_min;
4755 date[6] = (ipp_uchar_t)unixdate->tm_sec;
4756 date[7] = 0;
4757 date[8] = '+';
4758 date[9] = 0;
4759 date[10] = 0;
4760
4761 return (date);
4762 }
4763
4764
4765 /*
4766 * 'ippValidateAttribute()' - Validate the contents of an attribute.
4767 *
4768 * This function validates the contents of an attribute based on the name and
4769 * value tag. 1 is returned if the attribute is valid, 0 otherwise. On
4770 * failure, @link cupsLastErrorString@ is set to a human-readable message.
4771 *
4772 * @since CUPS 1.7/macOS 10.9@
4773 */
4774
4775 int /* O - 1 if valid, 0 otherwise */
4776 ippValidateAttribute(
4777 ipp_attribute_t *attr) /* I - Attribute */
4778 {
4779 int i; /* Looping var */
4780 char scheme[64], /* Scheme from URI */
4781 userpass[256], /* Username/password from URI */
4782 hostname[256], /* Hostname from URI */
4783 resource[1024]; /* Resource from URI */
4784 int port, /* Port number from URI */
4785 uri_status; /* URI separation status */
4786 const char *ptr; /* Pointer into string */
4787 ipp_attribute_t *colattr; /* Collection attribute */
4788 regex_t re; /* Regular expression */
4789 ipp_uchar_t *date; /* Current date value */
4790 static const char * const uri_status_strings[] =
4791 { /* URI status strings */
4792 "URI too large",
4793 "Bad arguments to function",
4794 "Bad resource in URI",
4795 "Bad port number in URI",
4796 "Bad hostname/address in URI",
4797 "Bad username in URI",
4798 "Bad scheme in URI",
4799 "Bad/empty URI",
4800 "OK",
4801 "Missing scheme in URI",
4802 "Unknown scheme in URI",
4803 "Missing resource in URI"
4804 };
4805
4806
4807 /*
4808 * Skip separators.
4809 */
4810
4811 if (!attr->name)
4812 return (1);
4813
4814 /*
4815 * Validate the attribute name.
4816 */
4817
4818 for (ptr = attr->name; *ptr; ptr ++)
4819 if (!isalnum(*ptr & 255) && *ptr != '-' && *ptr != '.' && *ptr != '_')
4820 break;
4821
4822 if (*ptr || ptr == attr->name)
4823 {
4824 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4825 _("\"%s\": Bad attribute name - invalid character "
4826 "(RFC 8011 section 5.1.4)."), attr->name);
4827 return (0);
4828 }
4829
4830 if ((ptr - attr->name) > 255)
4831 {
4832 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4833 _("\"%s\": Bad attribute name - bad length %d "
4834 "(RFC 8011 section 5.1.4)."), attr->name,
4835 (int)(ptr - attr->name));
4836 return (0);
4837 }
4838
4839 switch (attr->value_tag)
4840 {
4841 case IPP_TAG_INTEGER :
4842 break;
4843
4844 case IPP_TAG_BOOLEAN :
4845 for (i = 0; i < attr->num_values; i ++)
4846 {
4847 if (attr->values[i].boolean != 0 &&
4848 attr->values[i].boolean != 1)
4849 {
4850 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4851 _("\"%s\": Bad boolen value %d "
4852 "(RFC 8011 section 5.1.21)."), attr->name,
4853 attr->values[i].boolean);
4854 return (0);
4855 }
4856 }
4857 break;
4858
4859 case IPP_TAG_ENUM :
4860 for (i = 0; i < attr->num_values; i ++)
4861 {
4862 if (attr->values[i].integer < 1)
4863 {
4864 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4865 _("\"%s\": Bad enum value %d - out of range "
4866 "(RFC 8011 section 5.1.5)."), attr->name,
4867 attr->values[i].integer);
4868 return (0);
4869 }
4870 }
4871 break;
4872
4873 case IPP_TAG_STRING :
4874 for (i = 0; i < attr->num_values; i ++)
4875 {
4876 if (attr->values[i].unknown.length > IPP_MAX_OCTETSTRING)
4877 {
4878 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4879 _("\"%s\": Bad octetString value - bad length %d "
4880 "(RFC 8011 section 5.1.20)."), attr->name,
4881 attr->values[i].unknown.length);
4882 return (0);
4883 }
4884 }
4885 break;
4886
4887 case IPP_TAG_DATE :
4888 for (i = 0; i < attr->num_values; i ++)
4889 {
4890 date = attr->values[i].date;
4891
4892 if (date[2] < 1 || date[2] > 12)
4893 {
4894 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4895 _("\"%s\": Bad dateTime month %u "
4896 "(RFC 8011 section 5.1.15)."), attr->name, date[2]);
4897 return (0);
4898 }
4899
4900 if (date[3] < 1 || date[3] > 31)
4901 {
4902 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4903 _("\"%s\": Bad dateTime day %u "
4904 "(RFC 8011 section 5.1.15)."), attr->name, date[3]);
4905 return (0);
4906 }
4907
4908 if (date[4] > 23)
4909 {
4910 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4911 _("\"%s\": Bad dateTime hours %u "
4912 "(RFC 8011 section 5.1.15)."), attr->name, date[4]);
4913 return (0);
4914 }
4915
4916 if (date[5] > 59)
4917 {
4918 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4919 _("\"%s\": Bad dateTime minutes %u "
4920 "(RFC 8011 section 5.1.15)."), attr->name, date[5]);
4921 return (0);
4922 }
4923
4924 if (date[6] > 60)
4925 {
4926 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4927 _("\"%s\": Bad dateTime seconds %u "
4928 "(RFC 8011 section 5.1.15)."), attr->name, date[6]);
4929 return (0);
4930 }
4931
4932 if (date[7] > 9)
4933 {
4934 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4935 _("\"%s\": Bad dateTime deciseconds %u "
4936 "(RFC 8011 section 5.1.15)."), attr->name, date[7]);
4937 return (0);
4938 }
4939
4940 if (date[8] != '-' && date[8] != '+')
4941 {
4942 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4943 _("\"%s\": Bad dateTime UTC sign '%c' "
4944 "(RFC 8011 section 5.1.15)."), attr->name, date[8]);
4945 return (0);
4946 }
4947
4948 if (date[9] > 11)
4949 {
4950 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4951 _("\"%s\": Bad dateTime UTC hours %u "
4952 "(RFC 8011 section 5.1.15)."), attr->name, date[9]);
4953 return (0);
4954 }
4955
4956 if (date[10] > 59)
4957 {
4958 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4959 _("\"%s\": Bad dateTime UTC minutes %u "
4960 "(RFC 8011 section 5.1.15)."), attr->name, date[10]);
4961 return (0);
4962 }
4963 }
4964 break;
4965
4966 case IPP_TAG_RESOLUTION :
4967 for (i = 0; i < attr->num_values; i ++)
4968 {
4969 if (attr->values[i].resolution.xres <= 0)
4970 {
4971 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4972 _("\"%s\": Bad resolution value %dx%d%s - cross "
4973 "feed resolution must be positive "
4974 "(RFC 8011 section 5.1.16)."), attr->name,
4975 attr->values[i].resolution.xres,
4976 attr->values[i].resolution.yres,
4977 attr->values[i].resolution.units ==
4978 IPP_RES_PER_INCH ? "dpi" :
4979 attr->values[i].resolution.units ==
4980 IPP_RES_PER_CM ? "dpcm" : "unknown");
4981 return (0);
4982 }
4983
4984 if (attr->values[i].resolution.yres <= 0)
4985 {
4986 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
4987 _("\"%s\": Bad resolution value %dx%d%s - feed "
4988 "resolution must be positive "
4989 "(RFC 8011 section 5.1.16)."), attr->name,
4990 attr->values[i].resolution.xres,
4991 attr->values[i].resolution.yres,
4992 attr->values[i].resolution.units ==
4993 IPP_RES_PER_INCH ? "dpi" :
4994 attr->values[i].resolution.units ==
4995 IPP_RES_PER_CM ? "dpcm" : "unknown");
4996 return (0);
4997 }
4998
4999 if (attr->values[i].resolution.units != IPP_RES_PER_INCH &&
5000 attr->values[i].resolution.units != IPP_RES_PER_CM)
5001 {
5002 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5003 _("\"%s\": Bad resolution value %dx%d%s - bad "
5004 "units value (RFC 8011 section 5.1.16)."),
5005 attr->name, attr->values[i].resolution.xres,
5006 attr->values[i].resolution.yres,
5007 attr->values[i].resolution.units ==
5008 IPP_RES_PER_INCH ? "dpi" :
5009 attr->values[i].resolution.units ==
5010 IPP_RES_PER_CM ? "dpcm" : "unknown");
5011 return (0);
5012 }
5013 }
5014 break;
5015
5016 case IPP_TAG_RANGE :
5017 for (i = 0; i < attr->num_values; i ++)
5018 {
5019 if (attr->values[i].range.lower > attr->values[i].range.upper)
5020 {
5021 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5022 _("\"%s\": Bad rangeOfInteger value %d-%d - lower "
5023 "greater than upper (RFC 8011 section 5.1.14)."),
5024 attr->name, attr->values[i].range.lower,
5025 attr->values[i].range.upper);
5026 return (0);
5027 }
5028 }
5029 break;
5030
5031 case IPP_TAG_BEGIN_COLLECTION :
5032 for (i = 0; i < attr->num_values; i ++)
5033 {
5034 for (colattr = attr->values[i].collection->attrs;
5035 colattr;
5036 colattr = colattr->next)
5037 {
5038 if (!ippValidateAttribute(colattr))
5039 return (0);
5040 }
5041 }
5042 break;
5043
5044 case IPP_TAG_TEXT :
5045 case IPP_TAG_TEXTLANG :
5046 for (i = 0; i < attr->num_values; i ++)
5047 {
5048 for (ptr = attr->values[i].string.text; *ptr; ptr ++)
5049 {
5050 if ((*ptr & 0xe0) == 0xc0)
5051 {
5052 ptr ++;
5053 if ((*ptr & 0xc0) != 0x80)
5054 break;
5055 }
5056 else if ((*ptr & 0xf0) == 0xe0)
5057 {
5058 ptr ++;
5059 if ((*ptr & 0xc0) != 0x80)
5060 break;
5061 ptr ++;
5062 if ((*ptr & 0xc0) != 0x80)
5063 break;
5064 }
5065 else if ((*ptr & 0xf8) == 0xf0)
5066 {
5067 ptr ++;
5068 if ((*ptr & 0xc0) != 0x80)
5069 break;
5070 ptr ++;
5071 if ((*ptr & 0xc0) != 0x80)
5072 break;
5073 ptr ++;
5074 if ((*ptr & 0xc0) != 0x80)
5075 break;
5076 }
5077 else if (*ptr & 0x80)
5078 break;
5079 }
5080
5081 if (*ptr)
5082 {
5083 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5084 _("\"%s\": Bad text value \"%s\" - bad UTF-8 "
5085 "sequence (RFC 8011 section 5.1.2)."), attr->name,
5086 attr->values[i].string.text);
5087 return (0);
5088 }
5089
5090 if ((ptr - attr->values[i].string.text) > (IPP_MAX_TEXT - 1))
5091 {
5092 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5093 _("\"%s\": Bad text value \"%s\" - bad length %d "
5094 "(RFC 8011 section 5.1.2)."), attr->name,
5095 attr->values[i].string.text,
5096 (int)(ptr - attr->values[i].string.text));
5097 return (0);
5098 }
5099 }
5100 break;
5101
5102 case IPP_TAG_NAME :
5103 case IPP_TAG_NAMELANG :
5104 for (i = 0; i < attr->num_values; i ++)
5105 {
5106 for (ptr = attr->values[i].string.text; *ptr; ptr ++)
5107 {
5108 if ((*ptr & 0xe0) == 0xc0)
5109 {
5110 ptr ++;
5111 if ((*ptr & 0xc0) != 0x80)
5112 break;
5113 }
5114 else if ((*ptr & 0xf0) == 0xe0)
5115 {
5116 ptr ++;
5117 if ((*ptr & 0xc0) != 0x80)
5118 break;
5119 ptr ++;
5120 if ((*ptr & 0xc0) != 0x80)
5121 break;
5122 }
5123 else if ((*ptr & 0xf8) == 0xf0)
5124 {
5125 ptr ++;
5126 if ((*ptr & 0xc0) != 0x80)
5127 break;
5128 ptr ++;
5129 if ((*ptr & 0xc0) != 0x80)
5130 break;
5131 ptr ++;
5132 if ((*ptr & 0xc0) != 0x80)
5133 break;
5134 }
5135 else if (*ptr & 0x80)
5136 break;
5137 }
5138
5139 if (*ptr)
5140 {
5141 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5142 _("\"%s\": Bad name value \"%s\" - bad UTF-8 "
5143 "sequence (RFC 8011 section 5.1.3)."), attr->name,
5144 attr->values[i].string.text);
5145 return (0);
5146 }
5147
5148 if ((ptr - attr->values[i].string.text) > (IPP_MAX_NAME - 1))
5149 {
5150 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5151 _("\"%s\": Bad name value \"%s\" - bad length %d "
5152 "(RFC 8011 section 5.1.3)."), attr->name,
5153 attr->values[i].string.text,
5154 (int)(ptr - attr->values[i].string.text));
5155 return (0);
5156 }
5157 }
5158 break;
5159
5160 case IPP_TAG_KEYWORD :
5161 for (i = 0; i < attr->num_values; i ++)
5162 {
5163 for (ptr = attr->values[i].string.text; *ptr; ptr ++)
5164 if (!isalnum(*ptr & 255) && *ptr != '-' && *ptr != '.' &&
5165 *ptr != '_')
5166 break;
5167
5168 if (*ptr || ptr == attr->values[i].string.text)
5169 {
5170 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5171 _("\"%s\": Bad keyword value \"%s\" - invalid "
5172 "character (RFC 8011 section 5.1.4)."),
5173 attr->name, attr->values[i].string.text);
5174 return (0);
5175 }
5176
5177 if ((ptr - attr->values[i].string.text) > (IPP_MAX_KEYWORD - 1))
5178 {
5179 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5180 _("\"%s\": Bad keyword value \"%s\" - bad "
5181 "length %d (RFC 8011 section 5.1.4)."),
5182 attr->name, attr->values[i].string.text,
5183 (int)(ptr - attr->values[i].string.text));
5184 return (0);
5185 }
5186 }
5187 break;
5188
5189 case IPP_TAG_URI :
5190 for (i = 0; i < attr->num_values; i ++)
5191 {
5192 uri_status = httpSeparateURI(HTTP_URI_CODING_ALL,
5193 attr->values[i].string.text,
5194 scheme, sizeof(scheme),
5195 userpass, sizeof(userpass),
5196 hostname, sizeof(hostname),
5197 &port, resource, sizeof(resource));
5198
5199 if (uri_status < HTTP_URI_STATUS_OK)
5200 {
5201 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5202 _("\"%s\": Bad URI value \"%s\" - %s "
5203 "(RFC 8011 section 5.1.6)."), attr->name,
5204 attr->values[i].string.text,
5205 uri_status_strings[uri_status -
5206 HTTP_URI_STATUS_OVERFLOW]);
5207 return (0);
5208 }
5209
5210 if (strlen(attr->values[i].string.text) > (IPP_MAX_URI - 1))
5211 {
5212 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5213 _("\"%s\": Bad URI value \"%s\" - bad length %d "
5214 "(RFC 8011 section 5.1.6)."), attr->name,
5215 attr->values[i].string.text,
5216 (int)strlen(attr->values[i].string.text));
5217 }
5218 }
5219 break;
5220
5221 case IPP_TAG_URISCHEME :
5222 for (i = 0; i < attr->num_values; i ++)
5223 {
5224 ptr = attr->values[i].string.text;
5225 if (islower(*ptr & 255))
5226 {
5227 for (ptr ++; *ptr; ptr ++)
5228 if (!islower(*ptr & 255) && !isdigit(*ptr & 255) &&
5229 *ptr != '+' && *ptr != '-' && *ptr != '.')
5230 break;
5231 }
5232
5233 if (*ptr || ptr == attr->values[i].string.text)
5234 {
5235 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5236 _("\"%s\": Bad uriScheme value \"%s\" - bad "
5237 "characters (RFC 8011 section 5.1.7)."),
5238 attr->name, attr->values[i].string.text);
5239 return (0);
5240 }
5241
5242 if ((ptr - attr->values[i].string.text) > (IPP_MAX_URISCHEME - 1))
5243 {
5244 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5245 _("\"%s\": Bad uriScheme value \"%s\" - bad "
5246 "length %d (RFC 8011 section 5.1.7)."),
5247 attr->name, attr->values[i].string.text,
5248 (int)(ptr - attr->values[i].string.text));
5249 return (0);
5250 }
5251 }
5252 break;
5253
5254 case IPP_TAG_CHARSET :
5255 for (i = 0; i < attr->num_values; i ++)
5256 {
5257 for (ptr = attr->values[i].string.text; *ptr; ptr ++)
5258 if (!isprint(*ptr & 255) || isupper(*ptr & 255) ||
5259 isspace(*ptr & 255))
5260 break;
5261
5262 if (*ptr || ptr == attr->values[i].string.text)
5263 {
5264 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5265 _("\"%s\": Bad charset value \"%s\" - bad "
5266 "characters (RFC 8011 section 5.1.8)."),
5267 attr->name, attr->values[i].string.text);
5268 return (0);
5269 }
5270
5271 if ((ptr - attr->values[i].string.text) > (IPP_MAX_CHARSET - 1))
5272 {
5273 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5274 _("\"%s\": Bad charset value \"%s\" - bad "
5275 "length %d (RFC 8011 section 5.1.8)."),
5276 attr->name, attr->values[i].string.text,
5277 (int)(ptr - attr->values[i].string.text));
5278 return (0);
5279 }
5280 }
5281 break;
5282
5283 case IPP_TAG_LANGUAGE :
5284 /*
5285 * The following regular expression is derived from the ABNF for
5286 * language tags in RFC 4646. All I can say is that this is the
5287 * easiest way to check the values...
5288 */
5289
5290 if ((i = regcomp(&re,
5291 "^("
5292 "(([a-z]{2,3}(-[a-z][a-z][a-z]){0,3})|[a-z]{4,8})"
5293 /* language */
5294 "(-[a-z][a-z][a-z][a-z]){0,1}" /* script */
5295 "(-([a-z][a-z]|[0-9][0-9][0-9])){0,1}" /* region */
5296 "(-([a-z]{5,8}|[0-9][0-9][0-9]))*" /* variant */
5297 "(-[a-wy-z](-[a-z0-9]{2,8})+)*" /* extension */
5298 "(-x(-[a-z0-9]{1,8})+)*" /* privateuse */
5299 "|"
5300 "x(-[a-z0-9]{1,8})+" /* privateuse */
5301 "|"
5302 "[a-z]{1,3}(-[a-z][0-9]{2,8}){1,2}" /* grandfathered */
5303 ")$",
5304 REG_NOSUB | REG_EXTENDED)) != 0)
5305 {
5306 char temp[256]; /* Temporary error string */
5307
5308 regerror(i, &re, temp, sizeof(temp));
5309 ipp_set_error(IPP_STATUS_ERROR_INTERNAL,
5310 _("Unable to compile naturalLanguage regular "
5311 "expression: %s."), temp);
5312 return (0);
5313 }
5314
5315 for (i = 0; i < attr->num_values; i ++)
5316 {
5317 if (regexec(&re, attr->values[i].string.text, 0, NULL, 0))
5318 {
5319 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5320 _("\"%s\": Bad naturalLanguage value \"%s\" - bad "
5321 "characters (RFC 8011 section 5.1.9)."),
5322 attr->name, attr->values[i].string.text);
5323 regfree(&re);
5324 return (0);
5325 }
5326
5327 if (strlen(attr->values[i].string.text) > (IPP_MAX_LANGUAGE - 1))
5328 {
5329 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5330 _("\"%s\": Bad naturalLanguage value \"%s\" - bad "
5331 "length %d (RFC 8011 section 5.1.9)."),
5332 attr->name, attr->values[i].string.text,
5333 (int)strlen(attr->values[i].string.text));
5334 regfree(&re);
5335 return (0);
5336 }
5337 }
5338
5339 regfree(&re);
5340 break;
5341
5342 case IPP_TAG_MIMETYPE :
5343 /*
5344 * The following regular expression is derived from the ABNF for
5345 * MIME media types in RFC 2045 and 4288. All I can say is that this is
5346 * the easiest way to check the values...
5347 */
5348
5349 if ((i = regcomp(&re,
5350 "^"
5351 "[-a-zA-Z0-9!#$&.+^_]{1,127}" /* type-name */
5352 "/"
5353 "[-a-zA-Z0-9!#$&.+^_]{1,127}" /* subtype-name */
5354 "(;[-a-zA-Z0-9!#$&.+^_]{1,127}=" /* parameter= */
5355 "([-a-zA-Z0-9!#$&.+^_]{1,127}|\"[^\"]*\"))*"
5356 /* value */
5357 "$",
5358 REG_NOSUB | REG_EXTENDED)) != 0)
5359 {
5360 char temp[256]; /* Temporary error string */
5361
5362 regerror(i, &re, temp, sizeof(temp));
5363 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5364 _("Unable to compile mimeMediaType regular "
5365 "expression: %s."), temp);
5366 return (0);
5367 }
5368
5369 for (i = 0; i < attr->num_values; i ++)
5370 {
5371 if (regexec(&re, attr->values[i].string.text, 0, NULL, 0))
5372 {
5373 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5374 _("\"%s\": Bad mimeMediaType value \"%s\" - bad "
5375 "characters (RFC 8011 section 5.1.10)."),
5376 attr->name, attr->values[i].string.text);
5377 regfree(&re);
5378 return (0);
5379 }
5380
5381 if (strlen(attr->values[i].string.text) > (IPP_MAX_MIMETYPE - 1))
5382 {
5383 ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
5384 _("\"%s\": Bad mimeMediaType value \"%s\" - bad "
5385 "length %d (RFC 8011 section 5.1.10)."),
5386 attr->name, attr->values[i].string.text,
5387 (int)strlen(attr->values[i].string.text));
5388 regfree(&re);
5389 return (0);
5390 }
5391 }
5392
5393 regfree(&re);
5394 break;
5395
5396 default :
5397 break;
5398 }
5399
5400 return (1);
5401 }
5402
5403
5404 /*
5405 * 'ippValidateAttributes()' - Validate all attributes in an IPP message.
5406 *
5407 * This function validates the contents of the IPP message, including each
5408 * attribute. Like @link ippValidateAttribute@, @link cupsLastErrorString@ is
5409 * set to a human-readable message on failure.
5410 *
5411 * @since CUPS 1.7/macOS 10.9@
5412 */
5413
5414 int /* O - 1 if valid, 0 otherwise */
5415 ippValidateAttributes(ipp_t *ipp) /* I - IPP message */
5416 {
5417 ipp_attribute_t *attr; /* Current attribute */
5418
5419
5420 if (!ipp)
5421 return (1);
5422
5423 for (attr = ipp->attrs; attr; attr = attr->next)
5424 if (!ippValidateAttribute(attr))
5425 return (0);
5426
5427 return (1);
5428 }
5429
5430
5431 /*
5432 * 'ippWrite()' - Write data for an IPP message to a HTTP connection.
5433 */
5434
5435 ipp_state_t /* O - Current state */
5436 ippWrite(http_t *http, /* I - HTTP connection */
5437 ipp_t *ipp) /* I - IPP data */
5438 {
5439 DEBUG_printf(("ippWrite(http=%p, ipp=%p)", (void *)http, (void *)ipp));
5440
5441 if (!http)
5442 return (IPP_STATE_ERROR);
5443
5444 return (ippWriteIO(http, (ipp_iocb_t)httpWrite2, http->blocking, NULL, ipp));
5445 }
5446
5447
5448 /*
5449 * 'ippWriteFile()' - Write data for an IPP message to a file.
5450 *
5451 * @since CUPS 1.1.19/macOS 10.3@
5452 */
5453
5454 ipp_state_t /* O - Current state */
5455 ippWriteFile(int fd, /* I - HTTP data */
5456 ipp_t *ipp) /* I - IPP data */
5457 {
5458 DEBUG_printf(("ippWriteFile(fd=%d, ipp=%p)", fd, (void *)ipp));
5459
5460 ipp->state = IPP_STATE_IDLE;
5461
5462 return (ippWriteIO(&fd, (ipp_iocb_t)ipp_write_file, 1, NULL, ipp));
5463 }
5464
5465
5466 /*
5467 * 'ippWriteIO()' - Write data for an IPP message.
5468 *
5469 * @since CUPS 1.2/macOS 10.5@
5470 */
5471
5472 ipp_state_t /* O - Current state */
5473 ippWriteIO(void *dst, /* I - Destination */
5474 ipp_iocb_t cb, /* I - Write callback function */
5475 int blocking, /* I - Use blocking IO? */
5476 ipp_t *parent, /* I - Parent IPP message */
5477 ipp_t *ipp) /* I - IPP data */
5478 {
5479 int i; /* Looping var */
5480 int n; /* Length of data */
5481 unsigned char *buffer, /* Data buffer */
5482 *bufptr; /* Pointer into buffer */
5483 ipp_attribute_t *attr; /* Current attribute */
5484 _ipp_value_t *value; /* Current value */
5485
5486
5487 DEBUG_printf(("ippWriteIO(dst=%p, cb=%p, blocking=%d, parent=%p, ipp=%p)", (void *)dst, (void *)cb, blocking, (void *)parent, (void *)ipp));
5488
5489 if (!dst || !ipp)
5490 return (IPP_STATE_ERROR);
5491
5492 if ((buffer = (unsigned char *)_cupsBufferGet(IPP_BUF_SIZE)) == NULL)
5493 {
5494 DEBUG_puts("1ippWriteIO: Unable to get write buffer");
5495 return (IPP_STATE_ERROR);
5496 }
5497
5498 switch (ipp->state)
5499 {
5500 case IPP_STATE_IDLE :
5501 ipp->state ++; /* Avoid common problem... */
5502
5503 case IPP_STATE_HEADER :
5504 if (parent == NULL)
5505 {
5506 /*
5507 * Send the request header:
5508 *
5509 * Version = 2 bytes
5510 * Operation/Status Code = 2 bytes
5511 * Request ID = 4 bytes
5512 * Total = 8 bytes
5513 */
5514
5515 bufptr = buffer;
5516
5517 *bufptr++ = ipp->request.any.version[0];
5518 *bufptr++ = ipp->request.any.version[1];
5519 *bufptr++ = (ipp_uchar_t)(ipp->request.any.op_status >> 8);
5520 *bufptr++ = (ipp_uchar_t)ipp->request.any.op_status;
5521 *bufptr++ = (ipp_uchar_t)(ipp->request.any.request_id >> 24);
5522 *bufptr++ = (ipp_uchar_t)(ipp->request.any.request_id >> 16);
5523 *bufptr++ = (ipp_uchar_t)(ipp->request.any.request_id >> 8);
5524 *bufptr++ = (ipp_uchar_t)ipp->request.any.request_id;
5525
5526 DEBUG_printf(("2ippWriteIO: version=%d.%d", buffer[0], buffer[1]));
5527 DEBUG_printf(("2ippWriteIO: op_status=%04x",
5528 ipp->request.any.op_status));
5529 DEBUG_printf(("2ippWriteIO: request_id=%d",
5530 ipp->request.any.request_id));
5531
5532 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5533 {
5534 DEBUG_puts("1ippWriteIO: Could not write IPP header...");
5535 _cupsBufferRelease((char *)buffer);
5536 return (IPP_STATE_ERROR);
5537 }
5538 }
5539
5540 /*
5541 * Reset the state engine to point to the first attribute
5542 * in the request/response, with no current group.
5543 */
5544
5545 ipp->state = IPP_STATE_ATTRIBUTE;
5546 ipp->current = ipp->attrs;
5547 ipp->curtag = IPP_TAG_ZERO;
5548
5549 DEBUG_printf(("1ippWriteIO: ipp->current=%p", (void *)ipp->current));
5550
5551 /*
5552 * If blocking is disabled, stop here...
5553 */
5554
5555 if (!blocking)
5556 break;
5557
5558 case IPP_STATE_ATTRIBUTE :
5559 while (ipp->current != NULL)
5560 {
5561 /*
5562 * Write this attribute...
5563 */
5564
5565 bufptr = buffer;
5566 attr = ipp->current;
5567
5568 ipp->current = ipp->current->next;
5569
5570 if (!parent)
5571 {
5572 if (ipp->curtag != attr->group_tag)
5573 {
5574 /*
5575 * Send a group tag byte...
5576 */
5577
5578 ipp->curtag = attr->group_tag;
5579
5580 if (attr->group_tag == IPP_TAG_ZERO)
5581 continue;
5582
5583 DEBUG_printf(("2ippWriteIO: wrote group tag=%x(%s)",
5584 attr->group_tag, ippTagString(attr->group_tag)));
5585 *bufptr++ = (ipp_uchar_t)attr->group_tag;
5586 }
5587 else if (attr->group_tag == IPP_TAG_ZERO)
5588 continue;
5589 }
5590
5591 DEBUG_printf(("1ippWriteIO: %s (%s%s)", attr->name,
5592 attr->num_values > 1 ? "1setOf " : "",
5593 ippTagString(attr->value_tag)));
5594
5595 /*
5596 * Write the attribute tag and name.
5597 *
5598 * The attribute name length does not include the trailing nul
5599 * character in the source string.
5600 *
5601 * Collection values (parent != NULL) are written differently...
5602 */
5603
5604 if (parent == NULL)
5605 {
5606 /*
5607 * Get the length of the attribute name, and make sure it won't
5608 * overflow the buffer...
5609 */
5610
5611 if ((n = (int)strlen(attr->name)) > (IPP_BUF_SIZE - 8))
5612 {
5613 DEBUG_printf(("1ippWriteIO: Attribute name too long (%d)", n));
5614 _cupsBufferRelease((char *)buffer);
5615 return (IPP_STATE_ERROR);
5616 }
5617
5618 /*
5619 * Write the value tag, name length, and name string...
5620 */
5621
5622 DEBUG_printf(("2ippWriteIO: writing value tag=%x(%s)",
5623 attr->value_tag, ippTagString(attr->value_tag)));
5624 DEBUG_printf(("2ippWriteIO: writing name=%d,\"%s\"", n,
5625 attr->name));
5626
5627 if (attr->value_tag > 0xff)
5628 {
5629 *bufptr++ = IPP_TAG_EXTENSION;
5630 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 24);
5631 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 16);
5632 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 8);
5633 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5634 }
5635 else
5636 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5637
5638 *bufptr++ = (ipp_uchar_t)(n >> 8);
5639 *bufptr++ = (ipp_uchar_t)n;
5640 memcpy(bufptr, attr->name, (size_t)n);
5641 bufptr += n;
5642 }
5643 else
5644 {
5645 /*
5646 * Get the length of the attribute name, and make sure it won't
5647 * overflow the buffer...
5648 */
5649
5650 if ((n = (int)strlen(attr->name)) > (IPP_BUF_SIZE - 12))
5651 {
5652 DEBUG_printf(("1ippWriteIO: Attribute name too long (%d)", n));
5653 _cupsBufferRelease((char *)buffer);
5654 return (IPP_STATE_ERROR);
5655 }
5656
5657 /*
5658 * Write the member name tag, name length, name string, value tag,
5659 * and empty name for the collection member attribute...
5660 */
5661
5662 DEBUG_printf(("2ippWriteIO: writing value tag=%x(memberName)",
5663 IPP_TAG_MEMBERNAME));
5664 DEBUG_printf(("2ippWriteIO: writing name=%d,\"%s\"", n,
5665 attr->name));
5666 DEBUG_printf(("2ippWriteIO: writing value tag=%x(%s)",
5667 attr->value_tag, ippTagString(attr->value_tag)));
5668 DEBUG_puts("2ippWriteIO: writing name=0,\"\"");
5669
5670 *bufptr++ = IPP_TAG_MEMBERNAME;
5671 *bufptr++ = 0;
5672 *bufptr++ = 0;
5673 *bufptr++ = (ipp_uchar_t)(n >> 8);
5674 *bufptr++ = (ipp_uchar_t)n;
5675 memcpy(bufptr, attr->name, (size_t)n);
5676 bufptr += n;
5677
5678 if (attr->value_tag > 0xff)
5679 {
5680 *bufptr++ = IPP_TAG_EXTENSION;
5681 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 24);
5682 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 16);
5683 *bufptr++ = (ipp_uchar_t)(attr->value_tag >> 8);
5684 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5685 }
5686 else
5687 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5688
5689 *bufptr++ = 0;
5690 *bufptr++ = 0;
5691 }
5692
5693 /*
5694 * Now write the attribute value(s)...
5695 */
5696
5697 switch (attr->value_tag & ~IPP_TAG_CUPS_CONST)
5698 {
5699 case IPP_TAG_UNSUPPORTED_VALUE :
5700 case IPP_TAG_DEFAULT :
5701 case IPP_TAG_UNKNOWN :
5702 case IPP_TAG_NOVALUE :
5703 case IPP_TAG_NOTSETTABLE :
5704 case IPP_TAG_DELETEATTR :
5705 case IPP_TAG_ADMINDEFINE :
5706 *bufptr++ = 0;
5707 *bufptr++ = 0;
5708 break;
5709
5710 case IPP_TAG_INTEGER :
5711 case IPP_TAG_ENUM :
5712 for (i = 0, value = attr->values;
5713 i < attr->num_values;
5714 i ++, value ++)
5715 {
5716 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 9)
5717 {
5718 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5719 {
5720 DEBUG_puts("1ippWriteIO: Could not write IPP "
5721 "attribute...");
5722 _cupsBufferRelease((char *)buffer);
5723 return (IPP_STATE_ERROR);
5724 }
5725
5726 bufptr = buffer;
5727 }
5728
5729 if (i)
5730 {
5731 /*
5732 * Arrays and sets are done by sending additional
5733 * values with a zero-length name...
5734 */
5735
5736 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5737 *bufptr++ = 0;
5738 *bufptr++ = 0;
5739 }
5740
5741 /*
5742 * Integers and enumerations are both 4-byte signed
5743 * (twos-complement) values.
5744 *
5745 * Put the 2-byte length and 4-byte value into the buffer...
5746 */
5747
5748 *bufptr++ = 0;
5749 *bufptr++ = 4;
5750 *bufptr++ = (ipp_uchar_t)(value->integer >> 24);
5751 *bufptr++ = (ipp_uchar_t)(value->integer >> 16);
5752 *bufptr++ = (ipp_uchar_t)(value->integer >> 8);
5753 *bufptr++ = (ipp_uchar_t)value->integer;
5754 }
5755 break;
5756
5757 case IPP_TAG_BOOLEAN :
5758 for (i = 0, value = attr->values;
5759 i < attr->num_values;
5760 i ++, value ++)
5761 {
5762 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 6)
5763 {
5764 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5765 {
5766 DEBUG_puts("1ippWriteIO: Could not write IPP "
5767 "attribute...");
5768 _cupsBufferRelease((char *)buffer);
5769 return (IPP_STATE_ERROR);
5770 }
5771
5772 bufptr = buffer;
5773 }
5774
5775 if (i)
5776 {
5777 /*
5778 * Arrays and sets are done by sending additional
5779 * values with a zero-length name...
5780 */
5781
5782 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5783 *bufptr++ = 0;
5784 *bufptr++ = 0;
5785 }
5786
5787 /*
5788 * Boolean values are 1-byte; 0 = false, 1 = true.
5789 *
5790 * Put the 2-byte length and 1-byte value into the buffer...
5791 */
5792
5793 *bufptr++ = 0;
5794 *bufptr++ = 1;
5795 *bufptr++ = (ipp_uchar_t)value->boolean;
5796 }
5797 break;
5798
5799 case IPP_TAG_TEXT :
5800 case IPP_TAG_NAME :
5801 case IPP_TAG_KEYWORD :
5802 case IPP_TAG_URI :
5803 case IPP_TAG_URISCHEME :
5804 case IPP_TAG_CHARSET :
5805 case IPP_TAG_LANGUAGE :
5806 case IPP_TAG_MIMETYPE :
5807 for (i = 0, value = attr->values;
5808 i < attr->num_values;
5809 i ++, value ++)
5810 {
5811 if (i)
5812 {
5813 /*
5814 * Arrays and sets are done by sending additional
5815 * values with a zero-length name...
5816 */
5817
5818 DEBUG_printf(("2ippWriteIO: writing value tag=%x(%s)",
5819 attr->value_tag,
5820 ippTagString(attr->value_tag)));
5821 DEBUG_printf(("2ippWriteIO: writing name=0,\"\""));
5822
5823 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 3)
5824 {
5825 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5826 {
5827 DEBUG_puts("1ippWriteIO: Could not write IPP "
5828 "attribute...");
5829 _cupsBufferRelease((char *)buffer);
5830 return (IPP_STATE_ERROR);
5831 }
5832
5833 bufptr = buffer;
5834 }
5835
5836 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5837 *bufptr++ = 0;
5838 *bufptr++ = 0;
5839 }
5840
5841 if (value->string.text != NULL)
5842 n = (int)strlen(value->string.text);
5843 else
5844 n = 0;
5845
5846 if (n > (IPP_BUF_SIZE - 2))
5847 {
5848 DEBUG_printf(("1ippWriteIO: String too long (%d)", n));
5849 _cupsBufferRelease((char *)buffer);
5850 return (IPP_STATE_ERROR);
5851 }
5852
5853 DEBUG_printf(("2ippWriteIO: writing string=%d,\"%s\"", n,
5854 value->string.text));
5855
5856 if ((int)(IPP_BUF_SIZE - (bufptr - buffer)) < (n + 2))
5857 {
5858 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5859 {
5860 DEBUG_puts("1ippWriteIO: Could not write IPP "
5861 "attribute...");
5862 _cupsBufferRelease((char *)buffer);
5863 return (IPP_STATE_ERROR);
5864 }
5865
5866 bufptr = buffer;
5867 }
5868
5869 /*
5870 * All simple strings consist of the 2-byte length and
5871 * character data without the trailing nul normally found
5872 * in C strings. Also, strings cannot be longer than IPP_MAX_LENGTH
5873 * bytes since the 2-byte length is a signed (twos-complement)
5874 * value.
5875 *
5876 * Put the 2-byte length and string characters in the buffer.
5877 */
5878
5879 *bufptr++ = (ipp_uchar_t)(n >> 8);
5880 *bufptr++ = (ipp_uchar_t)n;
5881
5882 if (n > 0)
5883 {
5884 memcpy(bufptr, value->string.text, (size_t)n);
5885 bufptr += n;
5886 }
5887 }
5888 break;
5889
5890 case IPP_TAG_DATE :
5891 for (i = 0, value = attr->values;
5892 i < attr->num_values;
5893 i ++, value ++)
5894 {
5895 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 16)
5896 {
5897 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5898 {
5899 DEBUG_puts("1ippWriteIO: Could not write IPP "
5900 "attribute...");
5901 _cupsBufferRelease((char *)buffer);
5902 return (IPP_STATE_ERROR);
5903 }
5904
5905 bufptr = buffer;
5906 }
5907
5908 if (i)
5909 {
5910 /*
5911 * Arrays and sets are done by sending additional
5912 * values with a zero-length name...
5913 */
5914
5915 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5916 *bufptr++ = 0;
5917 *bufptr++ = 0;
5918 }
5919
5920 /*
5921 * Date values consist of a 2-byte length and an
5922 * 11-byte date/time structure defined by RFC 1903.
5923 *
5924 * Put the 2-byte length and 11-byte date/time
5925 * structure in the buffer.
5926 */
5927
5928 *bufptr++ = 0;
5929 *bufptr++ = 11;
5930 memcpy(bufptr, value->date, 11);
5931 bufptr += 11;
5932 }
5933 break;
5934
5935 case IPP_TAG_RESOLUTION :
5936 for (i = 0, value = attr->values;
5937 i < attr->num_values;
5938 i ++, value ++)
5939 {
5940 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 14)
5941 {
5942 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5943 {
5944 DEBUG_puts("1ippWriteIO: Could not write IPP "
5945 "attribute...");
5946 _cupsBufferRelease((char *)buffer);
5947 return (IPP_STATE_ERROR);
5948 }
5949
5950 bufptr = buffer;
5951 }
5952
5953 if (i)
5954 {
5955 /*
5956 * Arrays and sets are done by sending additional
5957 * values with a zero-length name...
5958 */
5959
5960 *bufptr++ = (ipp_uchar_t)attr->value_tag;
5961 *bufptr++ = 0;
5962 *bufptr++ = 0;
5963 }
5964
5965 /*
5966 * Resolution values consist of a 2-byte length,
5967 * 4-byte horizontal resolution value, 4-byte vertical
5968 * resolution value, and a 1-byte units value.
5969 *
5970 * Put the 2-byte length and resolution value data
5971 * into the buffer.
5972 */
5973
5974 *bufptr++ = 0;
5975 *bufptr++ = 9;
5976 *bufptr++ = (ipp_uchar_t)(value->resolution.xres >> 24);
5977 *bufptr++ = (ipp_uchar_t)(value->resolution.xres >> 16);
5978 *bufptr++ = (ipp_uchar_t)(value->resolution.xres >> 8);
5979 *bufptr++ = (ipp_uchar_t)value->resolution.xres;
5980 *bufptr++ = (ipp_uchar_t)(value->resolution.yres >> 24);
5981 *bufptr++ = (ipp_uchar_t)(value->resolution.yres >> 16);
5982 *bufptr++ = (ipp_uchar_t)(value->resolution.yres >> 8);
5983 *bufptr++ = (ipp_uchar_t)value->resolution.yres;
5984 *bufptr++ = (ipp_uchar_t)value->resolution.units;
5985 }
5986 break;
5987
5988 case IPP_TAG_RANGE :
5989 for (i = 0, value = attr->values;
5990 i < attr->num_values;
5991 i ++, value ++)
5992 {
5993 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 13)
5994 {
5995 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
5996 {
5997 DEBUG_puts("1ippWriteIO: Could not write IPP "
5998 "attribute...");
5999 _cupsBufferRelease((char *)buffer);
6000 return (IPP_STATE_ERROR);
6001 }
6002
6003 bufptr = buffer;
6004 }
6005
6006 if (i)
6007 {
6008 /*
6009 * Arrays and sets are done by sending additional
6010 * values with a zero-length name...
6011 */
6012
6013 *bufptr++ = (ipp_uchar_t)attr->value_tag;
6014 *bufptr++ = 0;
6015 *bufptr++ = 0;
6016 }
6017
6018 /*
6019 * Range values consist of a 2-byte length,
6020 * 4-byte lower value, and 4-byte upper value.
6021 *
6022 * Put the 2-byte length and range value data
6023 * into the buffer.
6024 */
6025
6026 *bufptr++ = 0;
6027 *bufptr++ = 8;
6028 *bufptr++ = (ipp_uchar_t)(value->range.lower >> 24);
6029 *bufptr++ = (ipp_uchar_t)(value->range.lower >> 16);
6030 *bufptr++ = (ipp_uchar_t)(value->range.lower >> 8);
6031 *bufptr++ = (ipp_uchar_t)value->range.lower;
6032 *bufptr++ = (ipp_uchar_t)(value->range.upper >> 24);
6033 *bufptr++ = (ipp_uchar_t)(value->range.upper >> 16);
6034 *bufptr++ = (ipp_uchar_t)(value->range.upper >> 8);
6035 *bufptr++ = (ipp_uchar_t)value->range.upper;
6036 }
6037 break;
6038
6039 case IPP_TAG_TEXTLANG :
6040 case IPP_TAG_NAMELANG :
6041 for (i = 0, value = attr->values;
6042 i < attr->num_values;
6043 i ++, value ++)
6044 {
6045 if (i)
6046 {
6047 /*
6048 * Arrays and sets are done by sending additional
6049 * values with a zero-length name...
6050 */
6051
6052 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 3)
6053 {
6054 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6055 {
6056 DEBUG_puts("1ippWriteIO: Could not write IPP "
6057 "attribute...");
6058 _cupsBufferRelease((char *)buffer);
6059 return (IPP_STATE_ERROR);
6060 }
6061
6062 bufptr = buffer;
6063 }
6064
6065 *bufptr++ = (ipp_uchar_t)attr->value_tag;
6066 *bufptr++ = 0;
6067 *bufptr++ = 0;
6068 }
6069
6070 /*
6071 * textWithLanguage and nameWithLanguage values consist
6072 * of a 2-byte length for both strings and their
6073 * individual lengths, a 2-byte length for the
6074 * character string, the character string without the
6075 * trailing nul, a 2-byte length for the character
6076 * set string, and the character set string without
6077 * the trailing nul.
6078 */
6079
6080 n = 4;
6081
6082 if (value->string.language != NULL)
6083 n += (int)strlen(value->string.language);
6084
6085 if (value->string.text != NULL)
6086 n += (int)strlen(value->string.text);
6087
6088 if (n > (IPP_BUF_SIZE - 2))
6089 {
6090 DEBUG_printf(("1ippWriteIO: text/nameWithLanguage value "
6091 "too long (%d)", n));
6092 _cupsBufferRelease((char *)buffer);
6093 return (IPP_STATE_ERROR);
6094 }
6095
6096 if ((int)(IPP_BUF_SIZE - (bufptr - buffer)) < (n + 2))
6097 {
6098 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6099 {
6100 DEBUG_puts("1ippWriteIO: Could not write IPP "
6101 "attribute...");
6102 _cupsBufferRelease((char *)buffer);
6103 return (IPP_STATE_ERROR);
6104 }
6105
6106 bufptr = buffer;
6107 }
6108
6109 /* Length of entire value */
6110 *bufptr++ = (ipp_uchar_t)(n >> 8);
6111 *bufptr++ = (ipp_uchar_t)n;
6112
6113 /* Length of language */
6114 if (value->string.language != NULL)
6115 n = (int)strlen(value->string.language);
6116 else
6117 n = 0;
6118
6119 *bufptr++ = (ipp_uchar_t)(n >> 8);
6120 *bufptr++ = (ipp_uchar_t)n;
6121
6122 /* Language */
6123 if (n > 0)
6124 {
6125 memcpy(bufptr, value->string.language, (size_t)n);
6126 bufptr += n;
6127 }
6128
6129 /* Length of text */
6130 if (value->string.text != NULL)
6131 n = (int)strlen(value->string.text);
6132 else
6133 n = 0;
6134
6135 *bufptr++ = (ipp_uchar_t)(n >> 8);
6136 *bufptr++ = (ipp_uchar_t)n;
6137
6138 /* Text */
6139 if (n > 0)
6140 {
6141 memcpy(bufptr, value->string.text, (size_t)n);
6142 bufptr += n;
6143 }
6144 }
6145 break;
6146
6147 case IPP_TAG_BEGIN_COLLECTION :
6148 for (i = 0, value = attr->values;
6149 i < attr->num_values;
6150 i ++, value ++)
6151 {
6152 /*
6153 * Collections are written with the begin-collection
6154 * tag first with a value of 0 length, followed by the
6155 * attributes in the collection, then the end-collection
6156 * value...
6157 */
6158
6159 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 5)
6160 {
6161 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6162 {
6163 DEBUG_puts("1ippWriteIO: Could not write IPP "
6164 "attribute...");
6165 _cupsBufferRelease((char *)buffer);
6166 return (IPP_STATE_ERROR);
6167 }
6168
6169 bufptr = buffer;
6170 }
6171
6172 if (i)
6173 {
6174 /*
6175 * Arrays and sets are done by sending additional
6176 * values with a zero-length name...
6177 */
6178
6179 *bufptr++ = (ipp_uchar_t)attr->value_tag;
6180 *bufptr++ = 0;
6181 *bufptr++ = 0;
6182 }
6183
6184 /*
6185 * Write a data length of 0 and flush the buffer...
6186 */
6187
6188 *bufptr++ = 0;
6189 *bufptr++ = 0;
6190
6191 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6192 {
6193 DEBUG_puts("1ippWriteIO: Could not write IPP "
6194 "attribute...");
6195 _cupsBufferRelease((char *)buffer);
6196 return (IPP_STATE_ERROR);
6197 }
6198
6199 bufptr = buffer;
6200
6201 /*
6202 * Then write the collection attribute...
6203 */
6204
6205 value->collection->state = IPP_STATE_IDLE;
6206
6207 if (ippWriteIO(dst, cb, 1, ipp,
6208 value->collection) == IPP_STATE_ERROR)
6209 {
6210 DEBUG_puts("1ippWriteIO: Unable to write collection value");
6211 _cupsBufferRelease((char *)buffer);
6212 return (IPP_STATE_ERROR);
6213 }
6214 }
6215 break;
6216
6217 default :
6218 for (i = 0, value = attr->values;
6219 i < attr->num_values;
6220 i ++, value ++)
6221 {
6222 if (i)
6223 {
6224 /*
6225 * Arrays and sets are done by sending additional
6226 * values with a zero-length name...
6227 */
6228
6229 if ((IPP_BUF_SIZE - (bufptr - buffer)) < 3)
6230 {
6231 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6232 {
6233 DEBUG_puts("1ippWriteIO: Could not write IPP "
6234 "attribute...");
6235 _cupsBufferRelease((char *)buffer);
6236 return (IPP_STATE_ERROR);
6237 }
6238
6239 bufptr = buffer;
6240 }
6241
6242 *bufptr++ = (ipp_uchar_t)attr->value_tag;
6243 *bufptr++ = 0;
6244 *bufptr++ = 0;
6245 }
6246
6247 /*
6248 * An unknown value might some new value that a
6249 * vendor has come up with. It consists of a
6250 * 2-byte length and the bytes in the unknown
6251 * value buffer.
6252 */
6253
6254 n = value->unknown.length;
6255
6256 if (n > (IPP_BUF_SIZE - 2))
6257 {
6258 DEBUG_printf(("1ippWriteIO: Data length too long (%d)",
6259 n));
6260 _cupsBufferRelease((char *)buffer);
6261 return (IPP_STATE_ERROR);
6262 }
6263
6264 if ((int)(IPP_BUF_SIZE - (bufptr - buffer)) < (n + 2))
6265 {
6266 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6267 {
6268 DEBUG_puts("1ippWriteIO: Could not write IPP "
6269 "attribute...");
6270 _cupsBufferRelease((char *)buffer);
6271 return (IPP_STATE_ERROR);
6272 }
6273
6274 bufptr = buffer;
6275 }
6276
6277 /* Length of unknown value */
6278 *bufptr++ = (ipp_uchar_t)(n >> 8);
6279 *bufptr++ = (ipp_uchar_t)n;
6280
6281 /* Value */
6282 if (n > 0)
6283 {
6284 memcpy(bufptr, value->unknown.data, (size_t)n);
6285 bufptr += n;
6286 }
6287 }
6288 break;
6289 }
6290
6291 /*
6292 * Write the data out...
6293 */
6294
6295 if (bufptr > buffer)
6296 {
6297 if ((*cb)(dst, buffer, (size_t)(bufptr - buffer)) < 0)
6298 {
6299 DEBUG_puts("1ippWriteIO: Could not write IPP attribute...");
6300 _cupsBufferRelease((char *)buffer);
6301 return (IPP_STATE_ERROR);
6302 }
6303
6304 DEBUG_printf(("2ippWriteIO: wrote %d bytes",
6305 (int)(bufptr - buffer)));
6306 }
6307
6308 /*
6309 * If blocking is disabled and we aren't at the end of the attribute
6310 * list, stop here...
6311 */
6312
6313 if (!blocking && ipp->current)
6314 break;
6315 }
6316
6317 if (ipp->current == NULL)
6318 {
6319 /*
6320 * Done with all of the attributes; add the end-of-attributes
6321 * tag or end-collection attribute...
6322 */
6323
6324 if (parent == NULL)
6325 {
6326 buffer[0] = IPP_TAG_END;
6327 n = 1;
6328 }
6329 else
6330 {
6331 buffer[0] = IPP_TAG_END_COLLECTION;
6332 buffer[1] = 0; /* empty name */
6333 buffer[2] = 0;
6334 buffer[3] = 0; /* empty value */
6335 buffer[4] = 0;
6336 n = 5;
6337 }
6338
6339 if ((*cb)(dst, buffer, (size_t)n) < 0)
6340 {
6341 DEBUG_puts("1ippWriteIO: Could not write IPP end-tag...");
6342 _cupsBufferRelease((char *)buffer);
6343 return (IPP_STATE_ERROR);
6344 }
6345
6346 ipp->state = IPP_STATE_DATA;
6347 }
6348 break;
6349
6350 case IPP_STATE_DATA :
6351 break;
6352
6353 default :
6354 break; /* anti-compiler-warning-code */
6355 }
6356
6357 _cupsBufferRelease((char *)buffer);
6358
6359 return (ipp->state);
6360 }
6361
6362
6363 /*
6364 * 'ipp_add_attr()' - Add a new attribute to the message.
6365 */
6366
6367 static ipp_attribute_t * /* O - New attribute */
6368 ipp_add_attr(ipp_t *ipp, /* I - IPP message */
6369 const char *name, /* I - Attribute name or NULL */
6370 ipp_tag_t group_tag, /* I - Group tag or IPP_TAG_ZERO */
6371 ipp_tag_t value_tag, /* I - Value tag or IPP_TAG_ZERO */
6372 int num_values) /* I - Number of values */
6373 {
6374 int alloc_values; /* Number of values to allocate */
6375 ipp_attribute_t *attr; /* New attribute */
6376
6377
6378 DEBUG_printf(("4ipp_add_attr(ipp=%p, name=\"%s\", group_tag=0x%x, value_tag=0x%x, num_values=%d)", (void *)ipp, name, group_tag, value_tag, num_values));
6379
6380 /*
6381 * Range check input...
6382 */
6383
6384 if (!ipp || num_values < 0)
6385 return (NULL);
6386
6387 /*
6388 * Allocate memory, rounding the allocation up as needed...
6389 */
6390
6391 if (num_values <= 1)
6392 alloc_values = 1;
6393 else
6394 alloc_values = (num_values + IPP_MAX_VALUES - 1) & ~(IPP_MAX_VALUES - 1);
6395
6396 attr = calloc(sizeof(ipp_attribute_t) +
6397 (size_t)(alloc_values - 1) * sizeof(_ipp_value_t), 1);
6398
6399 if (attr)
6400 {
6401 /*
6402 * Initialize attribute...
6403 */
6404
6405 if (name)
6406 attr->name = _cupsStrAlloc(name);
6407
6408 attr->group_tag = group_tag;
6409 attr->value_tag = value_tag;
6410 attr->num_values = num_values;
6411
6412 /*
6413 * Add it to the end of the linked list...
6414 */
6415
6416 if (ipp->last)
6417 ipp->last->next = attr;
6418 else
6419 ipp->attrs = attr;
6420
6421 ipp->prev = ipp->last;
6422 ipp->last = ipp->current = attr;
6423 }
6424
6425 DEBUG_printf(("5ipp_add_attr: Returning %p", (void *)attr));
6426
6427 return (attr);
6428 }
6429
6430
6431 /*
6432 * 'ipp_free_values()' - Free attribute values.
6433 */
6434
6435 static void
6436 ipp_free_values(ipp_attribute_t *attr, /* I - Attribute to free values from */
6437 int element,/* I - First value to free */
6438 int count) /* I - Number of values to free */
6439 {
6440 int i; /* Looping var */
6441 _ipp_value_t *value; /* Current value */
6442
6443
6444 DEBUG_printf(("4ipp_free_values(attr=%p, element=%d, count=%d)", (void *)attr, element, count));
6445
6446 if (!(attr->value_tag & IPP_TAG_CUPS_CONST))
6447 {
6448 /*
6449 * Free values as needed...
6450 */
6451
6452 switch (attr->value_tag)
6453 {
6454 case IPP_TAG_TEXTLANG :
6455 case IPP_TAG_NAMELANG :
6456 if (element == 0 && count == attr->num_values &&
6457 attr->values[0].string.language)
6458 {
6459 _cupsStrFree(attr->values[0].string.language);
6460 attr->values[0].string.language = NULL;
6461 }
6462 /* Fall through to other string values */
6463
6464 case IPP_TAG_TEXT :
6465 case IPP_TAG_NAME :
6466 case IPP_TAG_RESERVED_STRING :
6467 case IPP_TAG_KEYWORD :
6468 case IPP_TAG_URI :
6469 case IPP_TAG_URISCHEME :
6470 case IPP_TAG_CHARSET :
6471 case IPP_TAG_LANGUAGE :
6472 case IPP_TAG_MIMETYPE :
6473 for (i = count, value = attr->values + element;
6474 i > 0;
6475 i --, value ++)
6476 {
6477 _cupsStrFree(value->string.text);
6478 value->string.text = NULL;
6479 }
6480 break;
6481
6482 case IPP_TAG_DEFAULT :
6483 case IPP_TAG_UNKNOWN :
6484 case IPP_TAG_NOVALUE :
6485 case IPP_TAG_NOTSETTABLE :
6486 case IPP_TAG_DELETEATTR :
6487 case IPP_TAG_ADMINDEFINE :
6488 case IPP_TAG_INTEGER :
6489 case IPP_TAG_ENUM :
6490 case IPP_TAG_BOOLEAN :
6491 case IPP_TAG_DATE :
6492 case IPP_TAG_RESOLUTION :
6493 case IPP_TAG_RANGE :
6494 break;
6495
6496 case IPP_TAG_BEGIN_COLLECTION :
6497 for (i = count, value = attr->values + element;
6498 i > 0;
6499 i --, value ++)
6500 {
6501 ippDelete(value->collection);
6502 value->collection = NULL;
6503 }
6504 break;
6505
6506 case IPP_TAG_STRING :
6507 default :
6508 for (i = count, value = attr->values + element;
6509 i > 0;
6510 i --, value ++)
6511 {
6512 if (value->unknown.data)
6513 {
6514 free(value->unknown.data);
6515 value->unknown.data = NULL;
6516 }
6517 }
6518 break;
6519 }
6520 }
6521
6522 /*
6523 * If we are not freeing values from the end, move the remaining values up...
6524 */
6525
6526 if ((element + count) < attr->num_values)
6527 memmove(attr->values + element, attr->values + element + count,
6528 (size_t)(attr->num_values - count - element) * sizeof(_ipp_value_t));
6529
6530 attr->num_values -= count;
6531 }
6532
6533
6534 /*
6535 * 'ipp_get_code()' - Convert a C locale/charset name into an IPP language/charset code.
6536 *
6537 * This typically converts strings of the form "ll_CC", "ll-REGION", and "CHARSET_NUMBER"
6538 * to "ll-cc", "ll-region", and "charset-number", respectively.
6539 */
6540
6541 static char * /* O - Language code string */
6542 ipp_get_code(const char *value, /* I - Locale/charset string */
6543 char *buffer, /* I - String buffer */
6544 size_t bufsize) /* I - Size of string buffer */
6545 {
6546 char *bufptr, /* Pointer into buffer */
6547 *bufend; /* End of buffer */
6548
6549
6550 /*
6551 * Convert values to lowercase and change _ to - as needed...
6552 */
6553
6554 for (bufptr = buffer, bufend = buffer + bufsize - 1;
6555 *value && bufptr < bufend;
6556 value ++)
6557 if (*value == '_')
6558 *bufptr++ = '-';
6559 else
6560 *bufptr++ = (char)_cups_tolower(*value);
6561
6562 *bufptr = '\0';
6563
6564 /*
6565 * Return the converted string...
6566 */
6567
6568 return (buffer);
6569 }
6570
6571
6572 /*
6573 * 'ipp_lang_code()' - Convert a C locale name into an IPP language code.
6574 *
6575 * This typically converts strings of the form "ll_CC" and "ll-REGION" to "ll-cc" and
6576 * "ll-region", respectively. It also converts the "C" (POSIX) locale to "en".
6577 */
6578
6579 static char * /* O - Language code string */
6580 ipp_lang_code(const char *locale, /* I - Locale string */
6581 char *buffer, /* I - String buffer */
6582 size_t bufsize) /* I - Size of string buffer */
6583 {
6584 /*
6585 * Map POSIX ("C") locale to generic English, otherwise convert the locale string as-is.
6586 */
6587
6588 if (!_cups_strcasecmp(locale, "c"))
6589 {
6590 strlcpy(buffer, "en", bufsize);
6591 return (buffer);
6592 }
6593 else
6594 return (ipp_get_code(locale, buffer, bufsize));
6595 }
6596
6597
6598 /*
6599 * 'ipp_length()' - Compute the length of an IPP message or collection value.
6600 */
6601
6602 static size_t /* O - Size of IPP message */
6603 ipp_length(ipp_t *ipp, /* I - IPP message or collection */
6604 int collection) /* I - 1 if a collection, 0 otherwise */
6605 {
6606 int i; /* Looping var */
6607 size_t bytes; /* Number of bytes */
6608 ipp_attribute_t *attr; /* Current attribute */
6609 ipp_tag_t group; /* Current group */
6610 _ipp_value_t *value; /* Current value */
6611
6612
6613 DEBUG_printf(("3ipp_length(ipp=%p, collection=%d)", (void *)ipp, collection));
6614
6615 if (!ipp)
6616 {
6617 DEBUG_puts("4ipp_length: Returning 0 bytes");
6618 return (0);
6619 }
6620
6621 /*
6622 * Start with 8 bytes for the IPP message header...
6623 */
6624
6625 bytes = collection ? 0 : 8;
6626
6627 /*
6628 * Then add the lengths of each attribute...
6629 */
6630
6631 group = IPP_TAG_ZERO;
6632
6633 for (attr = ipp->attrs; attr != NULL; attr = attr->next)
6634 {
6635 if (attr->group_tag != group && !collection)
6636 {
6637 group = attr->group_tag;
6638 if (group == IPP_TAG_ZERO)
6639 continue;
6640
6641 bytes ++; /* Group tag */
6642 }
6643
6644 if (!attr->name)
6645 continue;
6646
6647 DEBUG_printf(("5ipp_length: attr->name=\"%s\", attr->num_values=%d, "
6648 "bytes=" CUPS_LLFMT, attr->name, attr->num_values, CUPS_LLCAST bytes));
6649
6650 if ((attr->value_tag & ~IPP_TAG_CUPS_CONST) < IPP_TAG_EXTENSION)
6651 bytes += (size_t)attr->num_values;/* Value tag for each value */
6652 else
6653 bytes += (size_t)(5 * attr->num_values);
6654 /* Value tag for each value */
6655 bytes += (size_t)(2 * attr->num_values);
6656 /* Name lengths */
6657 bytes += strlen(attr->name); /* Name */
6658 bytes += (size_t)(2 * attr->num_values);
6659 /* Value lengths */
6660
6661 if (collection)
6662 bytes += 5; /* Add membername overhead */
6663
6664 switch (attr->value_tag & ~IPP_TAG_CUPS_CONST)
6665 {
6666 case IPP_TAG_UNSUPPORTED_VALUE :
6667 case IPP_TAG_DEFAULT :
6668 case IPP_TAG_UNKNOWN :
6669 case IPP_TAG_NOVALUE :
6670 case IPP_TAG_NOTSETTABLE :
6671 case IPP_TAG_DELETEATTR :
6672 case IPP_TAG_ADMINDEFINE :
6673 break;
6674
6675 case IPP_TAG_INTEGER :
6676 case IPP_TAG_ENUM :
6677 bytes += (size_t)(4 * attr->num_values);
6678 break;
6679
6680 case IPP_TAG_BOOLEAN :
6681 bytes += (size_t)attr->num_values;
6682 break;
6683
6684 case IPP_TAG_TEXT :
6685 case IPP_TAG_NAME :
6686 case IPP_TAG_KEYWORD :
6687 case IPP_TAG_URI :
6688 case IPP_TAG_URISCHEME :
6689 case IPP_TAG_CHARSET :
6690 case IPP_TAG_LANGUAGE :
6691 case IPP_TAG_MIMETYPE :
6692 for (i = 0, value = attr->values;
6693 i < attr->num_values;
6694 i ++, value ++)
6695 if (value->string.text)
6696 bytes += strlen(value->string.text);
6697 break;
6698
6699 case IPP_TAG_DATE :
6700 bytes += (size_t)(11 * attr->num_values);
6701 break;
6702
6703 case IPP_TAG_RESOLUTION :
6704 bytes += (size_t)(9 * attr->num_values);
6705 break;
6706
6707 case IPP_TAG_RANGE :
6708 bytes += (size_t)(8 * attr->num_values);
6709 break;
6710
6711 case IPP_TAG_TEXTLANG :
6712 case IPP_TAG_NAMELANG :
6713 bytes += (size_t)(4 * attr->num_values);
6714 /* Charset + text length */
6715
6716 for (i = 0, value = attr->values;
6717 i < attr->num_values;
6718 i ++, value ++)
6719 {
6720 if (value->string.language)
6721 bytes += strlen(value->string.language);
6722
6723 if (value->string.text)
6724 bytes += strlen(value->string.text);
6725 }
6726 break;
6727
6728 case IPP_TAG_BEGIN_COLLECTION :
6729 for (i = 0, value = attr->values;
6730 i < attr->num_values;
6731 i ++, value ++)
6732 bytes += ipp_length(value->collection, 1);
6733 break;
6734
6735 default :
6736 for (i = 0, value = attr->values;
6737 i < attr->num_values;
6738 i ++, value ++)
6739 bytes += (size_t)value->unknown.length;
6740 break;
6741 }
6742 }
6743
6744 /*
6745 * Finally, add 1 byte for the "end of attributes" tag or 5 bytes
6746 * for the "end of collection" tag and return...
6747 */
6748
6749 if (collection)
6750 bytes += 5;
6751 else
6752 bytes ++;
6753
6754 DEBUG_printf(("4ipp_length: Returning " CUPS_LLFMT " bytes", CUPS_LLCAST bytes));
6755
6756 return (bytes);
6757 }
6758
6759
6760 /*
6761 * 'ipp_read_http()' - Semi-blocking read on a HTTP connection...
6762 */
6763
6764 static ssize_t /* O - Number of bytes read */
6765 ipp_read_http(http_t *http, /* I - Client connection */
6766 ipp_uchar_t *buffer, /* O - Buffer for data */
6767 size_t length) /* I - Total length */
6768 {
6769 ssize_t tbytes, /* Total bytes read */
6770 bytes; /* Bytes read this pass */
6771
6772
6773 DEBUG_printf(("7ipp_read_http(http=%p, buffer=%p, length=%d)", (void *)http, (void *)buffer, (int)length));
6774
6775 /*
6776 * Loop until all bytes are read...
6777 */
6778
6779 for (tbytes = 0, bytes = 0;
6780 tbytes < (int)length;
6781 tbytes += bytes, buffer += bytes)
6782 {
6783 DEBUG_printf(("9ipp_read_http: tbytes=" CUPS_LLFMT ", http->state=%d", CUPS_LLCAST tbytes, http->state));
6784
6785 if (http->state == HTTP_STATE_WAITING)
6786 break;
6787
6788 if (http->used == 0 && !http->blocking)
6789 {
6790 /*
6791 * Wait up to 10 seconds for more data on non-blocking sockets...
6792 */
6793
6794 if (!httpWait(http, 10000))
6795 {
6796 /*
6797 * Signal no data...
6798 */
6799
6800 bytes = -1;
6801 break;
6802 }
6803 }
6804 else if (http->used == 0 && http->timeout_value > 0)
6805 {
6806 /*
6807 * Wait up to timeout seconds for more data on blocking sockets...
6808 */
6809
6810 if (!httpWait(http, (int)(1000 * http->timeout_value)))
6811 {
6812 /*
6813 * Signal no data...
6814 */
6815
6816 bytes = -1;
6817 break;
6818 }
6819 }
6820
6821 if ((bytes = httpRead2(http, (char *)buffer, length - (size_t)tbytes)) < 0)
6822 {
6823 #ifdef WIN32
6824 break;
6825 #else
6826 if (errno != EAGAIN && errno != EINTR)
6827 break;
6828
6829 bytes = 0;
6830 #endif /* WIN32 */
6831 }
6832 else if (bytes == 0)
6833 break;
6834 }
6835
6836 /*
6837 * Return the number of bytes read...
6838 */
6839
6840 if (tbytes == 0 && bytes < 0)
6841 tbytes = -1;
6842
6843 DEBUG_printf(("8ipp_read_http: Returning " CUPS_LLFMT " bytes", CUPS_LLCAST tbytes));
6844
6845 return (tbytes);
6846 }
6847
6848
6849 /*
6850 * 'ipp_read_file()' - Read IPP data from a file.
6851 */
6852
6853 static ssize_t /* O - Number of bytes read */
6854 ipp_read_file(int *fd, /* I - File descriptor */
6855 ipp_uchar_t *buffer, /* O - Read buffer */
6856 size_t length) /* I - Number of bytes to read */
6857 {
6858 #ifdef WIN32
6859 return ((ssize_t)read(*fd, buffer, (unsigned)length));
6860 #else
6861 return (read(*fd, buffer, length));
6862 #endif /* WIN32 */
6863 }
6864
6865
6866 /*
6867 * 'ipp_set_error()' - Set a formatted, localized error string.
6868 */
6869
6870 static void
6871 ipp_set_error(ipp_status_t status, /* I - Status code */
6872 const char *format, /* I - Printf-style error string */
6873 ...) /* I - Additional arguments as needed */
6874 {
6875 va_list ap; /* Pointer to additional args */
6876 char buffer[2048]; /* Message buffer */
6877 cups_lang_t *lang = cupsLangDefault();
6878 /* Current language */
6879
6880
6881 va_start(ap, format);
6882 vsnprintf(buffer, sizeof(buffer), _cupsLangString(lang, format), ap);
6883 va_end(ap);
6884
6885 _cupsSetError(status, buffer, 0);
6886 }
6887
6888
6889 /*
6890 * 'ipp_set_value()' - Get the value element from an attribute, expanding it as
6891 * needed.
6892 */
6893
6894 static _ipp_value_t * /* O - IPP value element or NULL on error */
6895 ipp_set_value(ipp_t *ipp, /* IO - IPP message */
6896 ipp_attribute_t **attr, /* IO - IPP attribute */
6897 int element) /* I - Value number (0-based) */
6898 {
6899 ipp_attribute_t *temp, /* New attribute pointer */
6900 *current, /* Current attribute in list */
6901 *prev; /* Previous attribute in list */
6902 int alloc_values; /* Allocated values */
6903
6904
6905 /*
6906 * If we are setting an existing value element, return it...
6907 */
6908
6909 temp = *attr;
6910
6911 if (temp->num_values <= 1)
6912 alloc_values = 1;
6913 else
6914 alloc_values = (temp->num_values + IPP_MAX_VALUES - 1) &
6915 ~(IPP_MAX_VALUES - 1);
6916
6917 if (element < alloc_values)
6918 {
6919 if (element >= temp->num_values)
6920 temp->num_values = element + 1;
6921
6922 return (temp->values + element);
6923 }
6924
6925 /*
6926 * Otherwise re-allocate the attribute - we allocate in groups of IPP_MAX_VALUE
6927 * values when num_values > 1.
6928 */
6929
6930 if (alloc_values < IPP_MAX_VALUES)
6931 alloc_values = IPP_MAX_VALUES;
6932 else
6933 alloc_values += IPP_MAX_VALUES;
6934
6935 DEBUG_printf(("4ipp_set_value: Reallocating for up to %d values.",
6936 alloc_values));
6937
6938 /*
6939 * Reallocate memory...
6940 */
6941
6942 if ((temp = realloc(temp, sizeof(ipp_attribute_t) + (size_t)(alloc_values - 1) * sizeof(_ipp_value_t))) == NULL)
6943 {
6944 _cupsSetHTTPError(HTTP_STATUS_ERROR);
6945 DEBUG_puts("4ipp_set_value: Unable to resize attribute.");
6946 return (NULL);
6947 }
6948
6949 /*
6950 * Zero the new memory...
6951 */
6952
6953 memset(temp->values + temp->num_values, 0, (size_t)(alloc_values - temp->num_values) * sizeof(_ipp_value_t));
6954
6955 if (temp != *attr)
6956 {
6957 /*
6958 * Reset pointers in the list...
6959 */
6960
6961 if (ipp->current == *attr && ipp->prev)
6962 {
6963 /*
6964 * Use current "previous" pointer...
6965 */
6966
6967 prev = ipp->prev;
6968 }
6969 else
6970 {
6971 /*
6972 * Find this attribute in the linked list...
6973 */
6974
6975 for (prev = NULL, current = ipp->attrs;
6976 current && current != *attr;
6977 prev = current, current = current->next);
6978
6979 if (!current)
6980 {
6981 /*
6982 * This is a serious error!
6983 */
6984
6985 *attr = temp;
6986 _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
6987 _("IPP attribute is not a member of the message."), 1);
6988 DEBUG_puts("4ipp_set_value: Unable to find attribute in message.");
6989 return (NULL);
6990 }
6991 }
6992
6993 if (prev)
6994 prev->next = temp;
6995 else
6996 ipp->attrs = temp;
6997
6998 ipp->current = temp;
6999 ipp->prev = prev;
7000
7001 if (ipp->last == *attr)
7002 ipp->last = temp;
7003
7004 *attr = temp;
7005 }
7006
7007 /*
7008 * Return the value element...
7009 */
7010
7011 if (element >= temp->num_values)
7012 temp->num_values = element + 1;
7013
7014 return (temp->values + element);
7015 }
7016
7017
7018 /*
7019 * 'ipp_write_file()' - Write IPP data to a file.
7020 */
7021
7022 static ssize_t /* O - Number of bytes written */
7023 ipp_write_file(int *fd, /* I - File descriptor */
7024 ipp_uchar_t *buffer, /* I - Data to write */
7025 size_t length) /* I - Number of bytes to write */
7026 {
7027 #ifdef WIN32
7028 return ((ssize_t)write(*fd, buffer, (unsigned)length));
7029 #else
7030 return (write(*fd, buffer, length));
7031 #endif /* WIN32 */
7032 }
Unnamed repository; edit this file 'description' to name the repository.