1 /* 2 * Option routines for CUPS. 3 * 4 * Copyright 2007-2017 by Apple Inc. 5 * Copyright 1997-2007 by Easy Software Products. 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 22 23 /* 24 * Local functions... 25 */ 26 27 static int cups_compare_options(cups_option_t *a, cups_option_t *b); 28 static int cups_find_option(const char *name, int num_options, 29 cups_option_t *option, int prev, int *rdiff); 30 31 32 /* 33 * 'cupsAddIntegerOption()' - Add an integer option to an option array. 34 * 35 * New option arrays can be initialized simply by passing 0 for the 36 * "num_options" parameter. 37 * 38 * @since CUPS 2.2.4/macOS 10.13@ 39 */ 40 41 int /* O - Number of options */ 42 cupsAddIntegerOption( 43 const char *name, /* I - Name of option */ 44 int value, /* I - Value of option */ 45 int num_options, /* I - Number of options */ 46 cups_option_t **options) /* IO - Pointer to options */ 47 { 48 char strvalue[32]; /* String value */ 49 50 51 snprintf(strvalue, sizeof(strvalue), "%d", value); 52 53 return (cupsAddOption(name, strvalue, num_options, options)); 54 } 55 56 57 /* 58 * 'cupsAddOption()' - Add an option to an option array. 59 * 60 * New option arrays can be initialized simply by passing 0 for the 61 * "num_options" parameter. 62 */ 63 64 int /* O - Number of options */ 65 cupsAddOption(const char *name, /* I - Name of option */ 66 const char *value, /* I - Value of option */ 67 int num_options,/* I - Number of options */ 68 cups_option_t **options) /* IO - Pointer to options */ 69 { 70 cups_option_t *temp; /* Pointer to new option */ 71 int insert, /* Insertion point */ 72 diff; /* Result of search */ 73 74 75 DEBUG_printf(("2cupsAddOption(name=\"%s\", value=\"%s\", num_options=%d, options=%p)", name, value, num_options, (void *)options)); 76 77 if (!name || !name[0] || !value || !options || num_options < 0) 78 { 79 DEBUG_printf(("3cupsAddOption: Returning %d", num_options)); 80 return (num_options); 81 } 82 83 if (!_cups_strcasecmp(name, "cupsPrintQuality")) 84 num_options = cupsRemoveOption("print-quality", num_options, options); 85 else if (!_cups_strcasecmp(name, "print-quality")) 86 num_options = cupsRemoveOption("cupsPrintQuality", num_options, options); 87 88 /* 89 * Look for an existing option with the same name... 90 */ 91 92 if (num_options == 0) 93 { 94 insert = 0; 95 diff = 1; 96 } 97 else 98 { 99 insert = cups_find_option(name, num_options, *options, num_options - 1, 100 &diff); 101 102 if (diff > 0) 103 insert ++; 104 } 105 106 if (diff) 107 { 108 /* 109 * No matching option name... 110 */ 111 112 DEBUG_printf(("4cupsAddOption: New option inserted at index %d...", 113 insert)); 114 115 if (num_options == 0) 116 temp = (cups_option_t *)malloc(sizeof(cups_option_t)); 117 else 118 temp = (cups_option_t *)realloc(*options, sizeof(cups_option_t) * (size_t)(num_options + 1)); 119 120 if (!temp) 121 { 122 DEBUG_puts("3cupsAddOption: Unable to expand option array, returning 0"); 123 return (0); 124 } 125 126 *options = temp; 127 128 if (insert < num_options) 129 { 130 DEBUG_printf(("4cupsAddOption: Shifting %d options...", 131 (int)(num_options - insert))); 132 memmove(temp + insert + 1, temp + insert, (size_t)(num_options - insert) * sizeof(cups_option_t)); 133 } 134 135 temp += insert; 136 temp->name = _cupsStrAlloc(name); 137 num_options ++; 138 } 139 else 140 { 141 /* 142 * Match found; free the old value... 143 */ 144 145 DEBUG_printf(("4cupsAddOption: Option already exists at index %d...", 146 insert)); 147 148 temp = *options + insert; 149 _cupsStrFree(temp->value); 150 } 151 152 temp->value = _cupsStrAlloc(value); 153 154 DEBUG_printf(("3cupsAddOption: Returning %d", num_options)); 155 156 return (num_options); 157 } 158 159 160 /* 161 * 'cupsFreeOptions()' - Free all memory used by options. 162 */ 163 164 void 165 cupsFreeOptions( 166 int num_options, /* I - Number of options */ 167 cups_option_t *options) /* I - Pointer to options */ 168 { 169 int i; /* Looping var */ 170 171 172 DEBUG_printf(("cupsFreeOptions(num_options=%d, options=%p)", num_options, (void *)options)); 173 174 if (num_options <= 0 || !options) 175 return; 176 177 for (i = 0; i < num_options; i ++) 178 { 179 _cupsStrFree(options[i].name); 180 _cupsStrFree(options[i].value); 181 } 182 183 free(options); 184 } 185 186 187 /* 188 * 'cupsGetIntegerOption()' - Get an integer option value. 189 * 190 * INT_MIN is returned when the option does not exist, is not an integer, or 191 * exceeds the range of values for the "int" type. 192 * 193 * @since CUPS 2.2.4/macOS 10.13@ 194 */ 195 196 int /* O - Option value or @code INT_MIN@ */ 197 cupsGetIntegerOption( 198 const char *name, /* I - Name of option */ 199 int num_options, /* I - Number of options */ 200 cups_option_t *options) /* I - Options */ 201 { 202 const char *value = cupsGetOption(name, num_options, options); 203 /* String value of option */ 204 char *ptr; /* Pointer into string value */ 205 long intvalue; /* Integer value */ 206 207 208 if (!value || !*value) 209 return (INT_MIN); 210 211 intvalue = strtol(value, &ptr, 10); 212 if (intvalue < INT_MIN || intvalue > INT_MAX || *ptr) 213 return (INT_MIN); 214 215 return ((int)intvalue); 216 } 217 218 219 /* 220 * 'cupsGetOption()' - Get an option value. 221 */ 222 223 const char * /* O - Option value or @code NULL@ */ 224 cupsGetOption(const char *name, /* I - Name of option */ 225 int num_options,/* I - Number of options */ 226 cups_option_t *options) /* I - Options */ 227 { 228 int diff, /* Result of comparison */ 229 match; /* Matching index */ 230 231 232 DEBUG_printf(("2cupsGetOption(name=\"%s\", num_options=%d, options=%p)", name, num_options, (void *)options)); 233 234 if (!name || num_options <= 0 || !options) 235 { 236 DEBUG_puts("3cupsGetOption: Returning NULL"); 237 return (NULL); 238 } 239 240 match = cups_find_option(name, num_options, options, -1, &diff); 241 242 if (!diff) 243 { 244 DEBUG_printf(("3cupsGetOption: Returning \"%s\"", options[match].value)); 245 return (options[match].value); 246 } 247 248 DEBUG_puts("3cupsGetOption: Returning NULL"); 249 return (NULL); 250 } 251 252 253 /* 254 * 'cupsParseOptions()' - Parse options from a command-line argument. 255 * 256 * This function converts space-delimited name/value pairs according 257 * to the PAPI text option ABNF specification. Collection values 258 * ("name={a=... b=... c=...}") are stored with the curley brackets 259 * intact - use @code cupsParseOptions@ on the value to extract the 260 * collection attributes. 261 */ 262 263 int /* O - Number of options found */ 264 cupsParseOptions( 265 const char *arg, /* I - Argument to parse */ 266 int num_options, /* I - Number of options */ 267 cups_option_t **options) /* O - Options found */ 268 { 269 char *copyarg, /* Copy of input string */ 270 *ptr, /* Pointer into string */ 271 *name, /* Pointer to name */ 272 *value, /* Pointer to value */ 273 sep, /* Separator character */ 274 quote; /* Quote character */ 275 276 277 DEBUG_printf(("cupsParseOptions(arg=\"%s\", num_options=%d, options=%p)", arg, num_options, (void *)options)); 278 279 /* 280 * Range check input... 281 */ 282 283 if (!arg) 284 { 285 DEBUG_printf(("1cupsParseOptions: Returning %d", num_options)); 286 return (num_options); 287 } 288 289 if (!options || num_options < 0) 290 { 291 DEBUG_puts("1cupsParseOptions: Returning 0"); 292 return (0); 293 } 294 295 /* 296 * Make a copy of the argument string and then divide it up... 297 */ 298 299 if ((copyarg = strdup(arg)) == NULL) 300 { 301 DEBUG_puts("1cupsParseOptions: Unable to copy arg string"); 302 DEBUG_printf(("1cupsParseOptions: Returning %d", num_options)); 303 return (num_options); 304 } 305 306 if (*copyarg == '{') 307 { 308 /* 309 * Remove surrounding {} so we can parse "{name=value ... name=value}"... 310 */ 311 312 if ((ptr = copyarg + strlen(copyarg) - 1) > copyarg && *ptr == '}') 313 { 314 *ptr = '\0'; 315 ptr = copyarg + 1; 316 } 317 else 318 ptr = copyarg; 319 } 320 else 321 ptr = copyarg; 322 323 /* 324 * Skip leading spaces... 325 */ 326 327 while (_cups_isspace(*ptr)) 328 ptr ++; 329 330 /* 331 * Loop through the string... 332 */ 333 334 while (*ptr != '\0') 335 { 336 /* 337 * Get the name up to a SPACE, =, or end-of-string... 338 */ 339 340 name = ptr; 341 while (!strchr("\f\n\r\t\v =", *ptr) && *ptr) 342 ptr ++; 343 344 /* 345 * Avoid an empty name... 346 */ 347 348 if (ptr == name) 349 break; 350 351 /* 352 * Skip trailing spaces... 353 */ 354 355 while (_cups_isspace(*ptr)) 356 *ptr++ = '\0'; 357 358 if ((sep = *ptr) == '=') 359 *ptr++ = '\0'; 360 361 DEBUG_printf(("2cupsParseOptions: name=\"%s\"", name)); 362 363 if (sep != '=') 364 { 365 /* 366 * Boolean option... 367 */ 368 369 if (!_cups_strncasecmp(name, "no", 2)) 370 num_options = cupsAddOption(name + 2, "false", num_options, 371 options); 372 else 373 num_options = cupsAddOption(name, "true", num_options, options); 374 375 continue; 376 } 377 378 /* 379 * Remove = and parse the value... 380 */ 381 382 value = ptr; 383 384 while (*ptr && !_cups_isspace(*ptr)) 385 { 386 if (*ptr == ',') 387 ptr ++; 388 else if (*ptr == '\'' || *ptr == '\"') 389 { 390 /* 391 * Quoted string constant... 392 */ 393 394 quote = *ptr; 395 _cups_strcpy(ptr, ptr + 1); 396 397 while (*ptr != quote && *ptr) 398 { 399 if (*ptr == '\\' && ptr[1]) 400 _cups_strcpy(ptr, ptr + 1); 401 402 ptr ++; 403 } 404 405 if (*ptr) 406 _cups_strcpy(ptr, ptr + 1); 407 } 408 else if (*ptr == '{') 409 { 410 /* 411 * Collection value... 412 */ 413 414 int depth; 415 416 for (depth = 0; *ptr; ptr ++) 417 { 418 if (*ptr == '{') 419 depth ++; 420 else if (*ptr == '}') 421 { 422 depth --; 423 if (!depth) 424 { 425 ptr ++; 426 break; 427 } 428 } 429 else if (*ptr == '\\' && ptr[1]) 430 _cups_strcpy(ptr, ptr + 1); 431 } 432 } 433 else 434 { 435 /* 436 * Normal space-delimited string... 437 */ 438 439 while (*ptr && !_cups_isspace(*ptr)) 440 { 441 if (*ptr == '\\' && ptr[1]) 442 _cups_strcpy(ptr, ptr + 1); 443 444 ptr ++; 445 } 446 } 447 } 448 449 if (*ptr != '\0') 450 *ptr++ = '\0'; 451 452 DEBUG_printf(("2cupsParseOptions: value=\"%s\"", value)); 453 454 /* 455 * Skip trailing whitespace... 456 */ 457 458 while (_cups_isspace(*ptr)) 459 ptr ++; 460 461 /* 462 * Add the string value... 463 */ 464 465 num_options = cupsAddOption(name, value, num_options, options); 466 } 467 468 /* 469 * Free the copy of the argument we made and return the number of options 470 * found. 471 */ 472 473 free(copyarg); 474 475 DEBUG_printf(("1cupsParseOptions: Returning %d", num_options)); 476 477 return (num_options); 478 } 479 480 481 /* 482 * 'cupsRemoveOption()' - Remove an option from an option array. 483 * 484 * @since CUPS 1.2/macOS 10.5@ 485 */ 486 487 int /* O - New number of options */ 488 cupsRemoveOption( 489 const char *name, /* I - Option name */ 490 int num_options, /* I - Current number of options */ 491 cups_option_t **options) /* IO - Options */ 492 { 493 int i; /* Looping var */ 494 cups_option_t *option; /* Current option */ 495 496 497 DEBUG_printf(("2cupsRemoveOption(name=\"%s\", num_options=%d, options=%p)", name, num_options, (void *)options)); 498 499 /* 500 * Range check input... 501 */ 502 503 if (!name || num_options < 1 || !options) 504 { 505 DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options)); 506 return (num_options); 507 } 508 509 /* 510 * Loop for the option... 511 */ 512 513 for (i = num_options, option = *options; i > 0; i --, option ++) 514 if (!_cups_strcasecmp(name, option->name)) 515 break; 516 517 if (i) 518 { 519 /* 520 * Remove this option from the array... 521 */ 522 523 DEBUG_puts("4cupsRemoveOption: Found option, removing it..."); 524 525 num_options --; 526 i --; 527 528 _cupsStrFree(option->name); 529 _cupsStrFree(option->value); 530 531 if (i > 0) 532 memmove(option, option + 1, (size_t)i * sizeof(cups_option_t)); 533 } 534 535 /* 536 * Return the new number of options... 537 */ 538 539 DEBUG_printf(("3cupsRemoveOption: Returning %d", num_options)); 540 return (num_options); 541 } 542 543 544 /* 545 * '_cupsGet1284Values()' - Get 1284 device ID keys and values. 546 * 547 * The returned dictionary is a CUPS option array that can be queried with 548 * cupsGetOption and freed with cupsFreeOptions. 549 */ 550 551 int /* O - Number of key/value pairs */ 552 _cupsGet1284Values( 553 const char *device_id, /* I - IEEE-1284 device ID string */ 554 cups_option_t **values) /* O - Array of key/value pairs */ 555 { 556 int num_values; /* Number of values */ 557 char key[256], /* Key string */ 558 value[256], /* Value string */ 559 *ptr; /* Pointer into key/value */ 560 561 562 /* 563 * Range check input... 564 */ 565 566 if (values) 567 *values = NULL; 568 569 if (!device_id || !values) 570 return (0); 571 572 /* 573 * Parse the 1284 device ID value into keys and values. The format is 574 * repeating sequences of: 575 * 576 * [whitespace]key:value[whitespace]; 577 */ 578 579 num_values = 0; 580 while (*device_id) 581 { 582 while (_cups_isspace(*device_id)) 583 device_id ++; 584 585 if (!*device_id) 586 break; 587 588 for (ptr = key; *device_id && *device_id != ':'; device_id ++) 589 if (ptr < (key + sizeof(key) - 1)) 590 *ptr++ = *device_id; 591 592 if (!*device_id) 593 break; 594 595 while (ptr > key && _cups_isspace(ptr[-1])) 596 ptr --; 597 598 *ptr = '\0'; 599 device_id ++; 600 601 while (_cups_isspace(*device_id)) 602 device_id ++; 603 604 if (!*device_id) 605 break; 606 607 for (ptr = value; *device_id && *device_id != ';'; device_id ++) 608 if (ptr < (value + sizeof(value) - 1)) 609 *ptr++ = *device_id; 610 611 if (!*device_id) 612 break; 613 614 while (ptr > value && _cups_isspace(ptr[-1])) 615 ptr --; 616 617 *ptr = '\0'; 618 device_id ++; 619 620 num_values = cupsAddOption(key, value, num_values, values); 621 } 622 623 return (num_values); 624 } 625 626 627 /* 628 * 'cups_compare_options()' - Compare two options. 629 */ 630 631 static int /* O - Result of comparison */ 632 cups_compare_options(cups_option_t *a, /* I - First option */ 633 cups_option_t *b) /* I - Second option */ 634 { 635 return (_cups_strcasecmp(a->name, b->name)); 636 } 637 638 639 /* 640 * 'cups_find_option()' - Find an option using a binary search. 641 */ 642 643 static int /* O - Index of match */ 644 cups_find_option( 645 const char *name, /* I - Option name */ 646 int num_options, /* I - Number of options */ 647 cups_option_t *options, /* I - Options */ 648 int prev, /* I - Previous index */ 649 int *rdiff) /* O - Difference of match */ 650 { 651 int left, /* Low mark for binary search */ 652 right, /* High mark for binary search */ 653 current, /* Current index */ 654 diff; /* Result of comparison */ 655 cups_option_t key; /* Search key */ 656 657 658 DEBUG_printf(("7cups_find_option(name=\"%s\", num_options=%d, options=%p, prev=%d, rdiff=%p)", name, num_options, (void *)options, prev, (void *)rdiff)); 659 660 #ifdef DEBUG 661 for (left = 0; left < num_options; left ++) 662 DEBUG_printf(("9cups_find_option: options[%d].name=\"%s\", .value=\"%s\"", 663 left, options[left].name, options[left].value)); 664 #endif /* DEBUG */ 665 666 key.name = (char *)name; 667 668 if (prev >= 0) 669 { 670 /* 671 * Start search on either side of previous... 672 */ 673 674 if ((diff = cups_compare_options(&key, options + prev)) == 0 || 675 (diff < 0 && prev == 0) || 676 (diff > 0 && prev == (num_options - 1))) 677 { 678 *rdiff = diff; 679 return (prev); 680 } 681 else if (diff < 0) 682 { 683 /* 684 * Start with previous on right side... 685 */ 686 687 left = 0; 688 right = prev; 689 } 690 else 691 { 692 /* 693 * Start wih previous on left side... 694 */ 695 696 left = prev; 697 right = num_options - 1; 698 } 699 } 700 else 701 { 702 /* 703 * Start search in the middle... 704 */ 705 706 left = 0; 707 right = num_options - 1; 708 } 709 710 do 711 { 712 current = (left + right) / 2; 713 diff = cups_compare_options(&key, options + current); 714 715 if (diff == 0) 716 break; 717 else if (diff < 0) 718 right = current; 719 else 720 left = current; 721 } 722 while ((right - left) > 1); 723 724 if (diff != 0) 725 { 726 /* 727 * Check the last 1 or 2 elements... 728 */ 729 730 if ((diff = cups_compare_options(&key, options + left)) <= 0) 731 current = left; 732 else 733 { 734 diff = cups_compare_options(&key, options + right); 735 current = right; 736 } 737 } 738 739 /* 740 * Return the closest destination and the difference... 741 */ 742 743 *rdiff = diff; 744 745 return (current); 746 } 747
