cups/options.c

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