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