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