cups/testdest.c

   1 /*
   2  * CUPS destination API test program for CUPS.
   3  *
   4  * Copyright 2012-2016 by Apple Inc.
   5  *
   6  * These coded instructions, statements, and computer programs are the
   7  * property of Apple Inc. and are protected by Federal copyright
   8  * law.  Distribution and use rights are outlined in the file "LICENSE.txt"
   9  * which should have been included with this file.  If this file is
  10  * missing or damaged, see the license at "http://www.cups.org/".
  11  *
  12  * This file is subject to the Apple OS-Developed Software exception.
  13  */
  14
  15 /*
  16  * Include necessary headers...
  17  */
  18
  19 #include <stdio.h>
  20 #include <errno.h>
  21 #include "cups.h"
  22
  23
  24 /*
  25  * Local functions...
  26  */
  27
  28 static int      enum_cb(void *user_data, unsigned flags, cups_dest_t *dest);
  29 static void     localize(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *option, const char *value);
  30 static void     print_file(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *filename, int num_options, cups_option_t *options);
  31 static void     show_conflicts(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, int num_options, cups_option_t *options);
  32 static void     show_default(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *option);
  33 static void     show_media(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, unsigned flags, const char *name);
  34 static void     show_supported(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *option, const char *value);
  35 static void     usage(const char *arg) __attribute__((noreturn));
  36
  37
  38 /*
  39  * 'main()' - Main entry.
  40  */
  41
  42 int                                     /* O - Exit status */
  43 main(int  argc,                         /* I - Number of command-line arguments */
  44      char *argv[])                      /* I - Command-line arguments */
  45 {
  46   http_t        *http;                  /* Connection to destination */
  47   cups_dest_t   *dest = NULL;           /* Destination */
  48   cups_dinfo_t  *dinfo;                 /* Destination info */
  49
  50
  51   if (argc < 2)
  52     usage(NULL);
  53
  54   if (!strcmp(argv[1], "--enum"))
  55   {
  56     int                 i;              /* Looping var */
  57     cups_ptype_t        type = 0,       /* Printer type filter */
  58                         mask = 0;       /* Printer type mask */
  59
  60
  61     for (i = 2; i < argc; i ++)
  62     {
  63       if (!strcmp(argv[i], "grayscale"))
  64       {
  65         type |= CUPS_PRINTER_BW;
  66         mask |= CUPS_PRINTER_BW;
  67       }
  68       else if (!strcmp(argv[i], "color"))
  69       {
  70         type |= CUPS_PRINTER_COLOR;
  71         mask |= CUPS_PRINTER_COLOR;
  72       }
  73       else if (!strcmp(argv[i], "duplex"))
  74       {
  75         type |= CUPS_PRINTER_DUPLEX;
  76         mask |= CUPS_PRINTER_DUPLEX;
  77       }
  78       else if (!strcmp(argv[i], "staple"))
  79       {
  80         type |= CUPS_PRINTER_STAPLE;
  81         mask |= CUPS_PRINTER_STAPLE;
  82       }
  83       else if (!strcmp(argv[i], "small"))
  84       {
  85         type |= CUPS_PRINTER_SMALL;
  86         mask |= CUPS_PRINTER_SMALL;
  87       }
  88       else if (!strcmp(argv[i], "medium"))
  89       {
  90         type |= CUPS_PRINTER_MEDIUM;
  91         mask |= CUPS_PRINTER_MEDIUM;
  92       }
  93       else if (!strcmp(argv[i], "large"))
  94       {
  95         type |= CUPS_PRINTER_LARGE;
  96         mask |= CUPS_PRINTER_LARGE;
  97       }
  98       else
  99         usage(argv[i]);
 100     }
 101
 102     cupsEnumDests(CUPS_DEST_FLAGS_NONE, 5000, NULL, type, mask, enum_cb, NULL);
 103
 104     return (0);
 105   }
 106   else if (!strncmp(argv[1], "ipp://", 6) || !strncmp(argv[1], "ipps://", 7))
 107     dest = cupsGetDestWithURI(NULL, argv[1]);
 108   else
 109     dest = cupsGetNamedDest(CUPS_HTTP_DEFAULT, argv[1], NULL);
 110
 111   if (!dest)
 112   {
 113     printf("testdest: Unable to get destination \"%s\": %s\n", argv[1], cupsLastErrorString());
 114     return (1);
 115   }
 116
 117   if ((http = cupsConnectDest(dest, CUPS_DEST_FLAGS_NONE, 30000, NULL, NULL, 0, NULL, NULL)) == NULL)
 118   {
 119     printf("testdest: Unable to connect to destination \"%s\": %s\n", argv[1], cupsLastErrorString());
 120     return (1);
 121   }
 122
 123   if ((dinfo = cupsCopyDestInfo(http, dest)) == NULL)
 124   {
 125     printf("testdest: Unable to get information for destination \"%s\": %s\n", argv[1], cupsLastErrorString());
 126     return (1);
 127   }
 128
 129   if (argc == 2 || (!strcmp(argv[2], "supported") && argc < 6))
 130   {
 131     if (argc > 3)
 132       show_supported(http, dest, dinfo, argv[3], argv[4]);
 133     else if (argc > 2)
 134       show_supported(http, dest, dinfo, argv[3], NULL);
 135     else
 136       show_supported(http, dest, dinfo, NULL, NULL);
 137   }
 138   else if (!strcmp(argv[2], "conflicts") && argc > 3)
 139   {
 140     int                 i,              /* Looping var */
 141                         num_options = 0;/* Number of options */
 142     cups_option_t       *options = NULL;/* Options */
 143
 144     for (i = 3; i < argc; i ++)
 145       num_options = cupsParseOptions(argv[i], num_options, &options);
 146
 147     show_conflicts(http, dest, dinfo, num_options, options);
 148   }
 149   else if (!strcmp(argv[2], "default") && argc == 4)
 150   {
 151     show_default(http, dest, dinfo, argv[3]);
 152   }
 153   else if (!strcmp(argv[2], "localize") && argc < 6)
 154   {
 155     if (argc > 3)
 156       localize(http, dest, dinfo, argv[3], argv[4]);
 157     else if (argc > 2)
 158       localize(http, dest, dinfo, argv[3], NULL);
 159     else
 160       localize(http, dest, dinfo, NULL, NULL);
 161   }
 162   else if (!strcmp(argv[2], "media"))
 163   {
 164     int         i;                      /* Looping var */
 165     const char  *name = NULL;           /* Media name, if any */
 166     unsigned    flags = CUPS_MEDIA_FLAGS_DEFAULT;
 167                                         /* Media selection flags */
 168
 169     for (i = 3; i < argc; i ++)
 170     {
 171       if (!strcmp(argv[i], "borderless"))
 172         flags = CUPS_MEDIA_FLAGS_BORDERLESS;
 173       else if (!strcmp(argv[i], "duplex"))
 174         flags = CUPS_MEDIA_FLAGS_DUPLEX;
 175       else if (!strcmp(argv[i], "exact"))
 176         flags = CUPS_MEDIA_FLAGS_EXACT;
 177       else if (!strcmp(argv[i], "ready"))
 178         flags = CUPS_MEDIA_FLAGS_READY;
 179       else if (name)
 180         usage(argv[i]);
 181       else
 182         name = argv[i];
 183     }
 184
 185     show_media(http, dest, dinfo, flags, name);
 186   }
 187   else if (!strcmp(argv[2], "print") && argc > 3)
 188   {
 189     int                 i,              /* Looping var */
 190                         num_options = 0;/* Number of options */
 191     cups_option_t       *options = NULL;/* Options */
 192
 193     for (i = 4; i < argc; i ++)
 194       num_options = cupsParseOptions(argv[i], num_options, &options);
 195
 196     print_file(http, dest, dinfo, argv[3], num_options, options);
 197   }
 198   else
 199     usage(argv[2]);
 200
 201   return (0);
 202 }
 203
 204
 205 /*
 206  * 'enum_cb()' - Print the results from the enumeration of destinations.
 207  */
 208
 209 static int                              /* O - 1 to continue */
 210 enum_cb(void        *user_data,         /* I - User data (unused) */
 211         unsigned    flags,              /* I - Flags */
 212         cups_dest_t *dest)              /* I - Destination */
 213 {
 214   int   i;                              /* Looping var */
 215
 216
 217   (void)user_data;
 218   (void)flags;
 219
 220   if (dest->instance)
 221     printf("%s/%s:\n", dest->name, dest->instance);
 222   else
 223     printf("%s:\n", dest->name);
 224
 225   for (i = 0; i < dest->num_options; i ++)
 226     printf("    %s=\"%s\"\n", dest->options[i].name, dest->options[i].value);
 227
 228   return (1);
 229 }
 230
 231
 232 /*
 233  * 'localize()' - Localize an option and value.
 234  */
 235
 236 static void
 237 localize(http_t       *http,            /* I - Connection to destination */
 238          cups_dest_t  *dest,            /* I - Destination */
 239          cups_dinfo_t *dinfo,           /* I - Destination information */
 240          const char   *option,          /* I - Option */
 241          const char   *value)           /* I - Value, if any */
 242 {
 243   ipp_attribute_t       *attr;          /* Attribute */
 244   int                   i,              /* Looping var */
 245                         count;          /* Number of values */
 246
 247
 248   if (!option)
 249   {
 250     attr = cupsFindDestSupported(http, dest, dinfo, "job-creation-attributes");
 251     if (attr)
 252     {
 253       count = ippGetCount(attr);
 254       for (i = 0; i < count; i ++)
 255         localize(http, dest, dinfo, ippGetString(attr, i, NULL), NULL);
 256     }
 257     else
 258     {
 259       static const char * const options[] =
 260       {                                 /* List of standard options */
 261         CUPS_COPIES,
 262         CUPS_FINISHINGS,
 263         CUPS_MEDIA,
 264         CUPS_NUMBER_UP,
 265         CUPS_ORIENTATION,
 266         CUPS_PRINT_COLOR_MODE,
 267         CUPS_PRINT_QUALITY,
 268         CUPS_SIDES
 269       };
 270
 271       puts("No job-creation-attributes-supported attribute, probing instead.");
 272
 273       for (i = 0; i < (int)(sizeof(options) / sizeof(options[0])); i ++)
 274         if (cupsCheckDestSupported(http, dest, dinfo, options[i], NULL))
 275           localize(http, dest, dinfo, options[i], NULL);
 276     }
 277   }
 278   else if (!value)
 279   {
 280     printf("%s (%s)\n", option, cupsLocalizeDestOption(http, dest, dinfo, option));
 281
 282     if ((attr = cupsFindDestSupported(http, dest, dinfo, option)) != NULL)
 283     {
 284       count = ippGetCount(attr);
 285
 286       switch (ippGetValueTag(attr))
 287       {
 288         case IPP_TAG_INTEGER :
 289             for (i = 0; i < count; i ++)
 290               printf("  %d\n", ippGetInteger(attr, i));
 291             break;
 292
 293         case IPP_TAG_ENUM :
 294             for (i = 0; i < count; i ++)
 295               printf("  %s\n", ippEnumString(option, ippGetInteger(attr, i)));
 296             break;
 297
 298         case IPP_TAG_RANGE :
 299             for (i = 0; i < count; i ++)
 300             {
 301               int upper, lower = ippGetRange(attr, i, &upper);
 302
 303               printf("  %d-%d\n", lower, upper);
 304             }
 305             break;
 306
 307         case IPP_TAG_RESOLUTION :
 308             for (i = 0; i < count; i ++)
 309             {
 310               int xres, yres;
 311               ipp_res_t units;
 312               xres = ippGetResolution(attr, i, &yres, &units);
 313
 314               if (xres == yres)
 315                 printf("  %d%s\n", xres, units == IPP_RES_PER_INCH ? "dpi" : "dpcm");
 316               else
 317                 printf("  %dx%d%s\n", xres, yres, units == IPP_RES_PER_INCH ? "dpi" : "dpcm");
 318             }
 319             break;
 320
 321         case IPP_TAG_TEXTLANG :
 322         case IPP_TAG_NAMELANG :
 323         case IPP_TAG_TEXT :
 324         case IPP_TAG_NAME :
 325         case IPP_TAG_KEYWORD :
 326         case IPP_TAG_URI :
 327         case IPP_TAG_URISCHEME :
 328         case IPP_TAG_CHARSET :
 329         case IPP_TAG_LANGUAGE :
 330         case IPP_TAG_MIMETYPE :
 331             for (i = 0; i < count; i ++)
 332               printf("  %s (%s)\n", ippGetString(attr, i, NULL), cupsLocalizeDestValue(http, dest, dinfo, option, ippGetString(attr, i, NULL)));
 333             break;
 334
 335         case IPP_TAG_STRING :
 336             for (i = 0; i < count; i ++)
 337             {
 338               int j, len;
 339               unsigned char *data = ippGetOctetString(attr, i, &len);
 340
 341               fputs("  ", stdout);
 342               for (j = 0; j < len; j ++)
 343               {
 344                 if (data[j] < ' ' || data[j] >= 0x7f)
 345                   printf("<%02X>", data[j]);
 346                 else
 347                   putchar(data[j]);
 348               }
 349               putchar('\n');
 350             }
 351             break;
 352
 353         case IPP_TAG_BOOLEAN :
 354             break;
 355
 356         default :
 357             printf("  %s\n", ippTagString(ippGetValueTag(attr)));
 358             break;
 359       }
 360     }
 361
 362   }
 363   else
 364     puts(cupsLocalizeDestValue(http, dest, dinfo, option, value));
 365 }
 366
 367
 368 /*
 369  * 'print_file()' - Print a file.
 370  */
 371
 372 static void
 373 print_file(http_t        *http,         /* I - Connection to destination */
 374            cups_dest_t   *dest,         /* I - Destination */
 375            cups_dinfo_t  *dinfo,        /* I - Destination information */
 376            const char    *filename,     /* I - File to print */
 377            int           num_options,   /* I - Number of options */
 378            cups_option_t *options)      /* I - Options */
 379 {
 380   cups_file_t   *fp;                    /* File to print */
 381   int           job_id;                 /* Job ID */
 382   ipp_status_t  status;                 /* Submission status */
 383   const char    *title;                 /* Title of job */
 384   char          buffer[32768];          /* File buffer */
 385   ssize_t       bytes;                  /* Bytes read/to write */
 386
 387
 388   if ((fp = cupsFileOpen(filename, "r")) == NULL)
 389   {
 390     printf("Unable to open \"%s\": %s\n", filename, strerror(errno));
 391     return;
 392   }
 393
 394   if ((title = strrchr(filename, '/')) != NULL)
 395     title ++;
 396   else
 397     title = filename;
 398
 399   if ((status = cupsCreateDestJob(http, dest, dinfo, &job_id, title, num_options, options)) > IPP_STATUS_OK_IGNORED_OR_SUBSTITUTED)
 400   {
 401     printf("Unable to create job: %s\n", cupsLastErrorString());
 402     cupsFileClose(fp);
 403     return;
 404   }
 405
 406   printf("Created job ID: %d\n", job_id);
 407
 408   if (cupsStartDestDocument(http, dest, dinfo, job_id, title, CUPS_FORMAT_AUTO, 0, NULL, 1) != HTTP_STATUS_CONTINUE)
 409   {
 410     printf("Unable to send document: %s\n", cupsLastErrorString());
 411     cupsFileClose(fp);
 412     return;
 413   }
 414
 415   while ((bytes = cupsFileRead(fp, buffer, sizeof(buffer))) > 0)
 416   {
 417     if (cupsWriteRequestData(http, buffer, (size_t)bytes) != HTTP_STATUS_CONTINUE)
 418     {
 419       printf("Unable to write document data: %s\n", cupsLastErrorString());
 420       break;
 421     }
 422   }
 423
 424   cupsFileClose(fp);
 425
 426   if ((status = cupsFinishDestDocument(http, dest, dinfo)) > IPP_STATUS_OK_IGNORED_OR_SUBSTITUTED)
 427   {
 428     printf("Unable to send document: %s\n", cupsLastErrorString());
 429     return;
 430   }
 431
 432   puts("Job queued.");
 433 }
 434
 435
 436 /*
 437  * 'show_conflicts()' - Show conflicts for selected options.
 438  */
 439
 440 static void
 441 show_conflicts(
 442     http_t        *http,                /* I - Connection to destination */
 443     cups_dest_t   *dest,                /* I - Destination */
 444     cups_dinfo_t  *dinfo,               /* I - Destination information */
 445     int           num_options,          /* I - Number of options */
 446     cups_option_t *options)             /* I - Options */
 447 {
 448   (void)http;
 449   (void)dest;
 450   (void)dinfo;
 451   (void)num_options;
 452   (void)options;
 453 }
 454
 455
 456 /*
 457  * 'show_default()' - Show default value for option.
 458  */
 459
 460 static void
 461 show_default(http_t       *http,        /* I - Connection to destination */
 462              cups_dest_t  *dest,        /* I - Destination */
 463              cups_dinfo_t *dinfo,       /* I - Destination information */
 464              const char  *option)       /* I - Option */
 465 {
 466   (void)http;
 467   (void)dest;
 468   (void)dinfo;
 469   (void)option;
 470 }
 471
 472
 473 /*
 474  * 'show_media()' - Show available media.
 475  */
 476
 477 static void
 478 show_media(http_t       *http,          /* I - Connection to destination */
 479            cups_dest_t  *dest,          /* I - Destination */
 480            cups_dinfo_t *dinfo,         /* I - Destination information */
 481            unsigned     flags,          /* I - Media flags */
 482            const char   *name)          /* I - Size name */
 483 {
 484   int           i,                      /* Looping var */
 485                 count;                  /* Number of sizes */
 486   cups_size_t   size;                   /* Media size info */
 487
 488
 489   if (name)
 490   {
 491     double      dw, dl;                 /* Width and length from name */
 492     char        units[32];              /* Units */
 493     int         width,                  /* Width in 100ths of millimeters */
 494                 length;                 /* Length in 100ths of millimeters */
 495
 496
 497     if (sscanf(name, "%lfx%lf%31s", &dw, &dl, units) == 3)
 498     {
 499       if (!strcmp(units, "in"))
 500       {
 501         width  = (int)(dw * 2540.0);
 502         length = (int)(dl * 2540.0);
 503       }
 504       else if (!strcmp(units, "mm"))
 505       {
 506         width  = (int)(dw * 100.0);
 507         length = (int)(dl * 100.0);
 508       }
 509       else
 510       {
 511         puts("  bad units in size");
 512         return;
 513       }
 514
 515       if (cupsGetDestMediaBySize(http, dest, dinfo, width, length, flags, &size))
 516       {
 517         printf("  %s (%s) %dx%d B%d L%d R%d T%d\n", size.media, cupsLocalizeDestMedia(http, dest, dinfo, flags, &size), size.width, size.length, size.bottom, size.left, size.right, size.top);
 518       }
 519       else
 520       {
 521         puts("  not supported");
 522       }
 523     }
 524     else if (cupsGetDestMediaByName(http, dest, dinfo, name, flags, &size))
 525     {
 526       printf("  %s (%s) %dx%d B%d L%d R%d T%d\n", size.media, cupsLocalizeDestMedia(http, dest, dinfo, flags, &size), size.width, size.length, size.bottom, size.left, size.right, size.top);
 527     }
 528     else
 529     {
 530       puts("  not supported");
 531     }
 532   }
 533   else
 534   {
 535     count = cupsGetDestMediaCount(http, dest, dinfo, flags);
 536     printf("%d size%s:\n", count, count == 1 ? "" : "s");
 537
 538     for (i = 0; i < count; i ++)
 539     {
 540       if (cupsGetDestMediaByIndex(http, dest, dinfo, i, flags, &size))
 541         printf("  %s (%s) %dx%d B%d L%d R%d T%d\n", size.media, cupsLocalizeDestMedia(http, dest, dinfo, flags, &size), size.width, size.length, size.bottom, size.left, size.right, size.top);
 542       else
 543         puts("  error");
 544     }
 545   }
 546 }
 547
 548
 549 /*
 550  * 'show_supported()' - Show supported options, values, etc.
 551  */
 552
 553 static void
 554 show_supported(http_t       *http,      /* I - Connection to destination */
 555                cups_dest_t  *dest,      /* I - Destination */
 556                cups_dinfo_t *dinfo,     /* I - Destination information */
 557                const char   *option,    /* I - Option, if any */
 558                const char   *value)     /* I - Value, if any */
 559 {
 560   ipp_attribute_t       *attr;          /* Attribute */
 561   int                   i,              /* Looping var */
 562                         count;          /* Number of values */
 563
 564
 565   if (!option)
 566   {
 567     attr = cupsFindDestSupported(http, dest, dinfo, "job-creation-attributes");
 568     if (attr)
 569     {
 570       count = ippGetCount(attr);
 571       for (i = 0; i < count; i ++)
 572         show_supported(http, dest, dinfo, ippGetString(attr, i, NULL), NULL);
 573     }
 574     else
 575     {
 576       static const char * const options[] =
 577       {                                 /* List of standard options */
 578         CUPS_COPIES,
 579         CUPS_FINISHINGS,
 580         CUPS_MEDIA,
 581         CUPS_NUMBER_UP,
 582         CUPS_ORIENTATION,
 583         CUPS_PRINT_COLOR_MODE,
 584         CUPS_PRINT_QUALITY,
 585         CUPS_SIDES
 586       };
 587
 588       puts("No job-creation-attributes-supported attribute, probing instead.");
 589
 590       for (i = 0; i < (int)(sizeof(options) / sizeof(options[0])); i ++)
 591         if (cupsCheckDestSupported(http, dest, dinfo, options[i], NULL))
 592           show_supported(http, dest, dinfo, options[i], NULL);
 593     }
 594   }
 595   else if (!value)
 596   {
 597     puts(option);
 598     if ((attr = cupsFindDestSupported(http, dest, dinfo, option)) != NULL)
 599     {
 600       count = ippGetCount(attr);
 601
 602       switch (ippGetValueTag(attr))
 603       {
 604         case IPP_TAG_INTEGER :
 605             for (i = 0; i < count; i ++)
 606               printf("  %d\n", ippGetInteger(attr, i));
 607             break;
 608
 609         case IPP_TAG_ENUM :
 610             for (i = 0; i < count; i ++)
 611               printf("  %s\n", ippEnumString(option, ippGetInteger(attr, i)));
 612             break;
 613
 614         case IPP_TAG_RANGE :
 615             for (i = 0; i < count; i ++)
 616             {
 617               int upper, lower = ippGetRange(attr, i, &upper);
 618
 619               printf("  %d-%d\n", lower, upper);
 620             }
 621             break;
 622
 623         case IPP_TAG_RESOLUTION :
 624             for (i = 0; i < count; i ++)
 625             {
 626               int xres, yres;
 627               ipp_res_t units;
 628               xres = ippGetResolution(attr, i, &yres, &units);
 629
 630               if (xres == yres)
 631                 printf("  %d%s\n", xres, units == IPP_RES_PER_INCH ? "dpi" : "dpcm");
 632               else
 633                 printf("  %dx%d%s\n", xres, yres, units == IPP_RES_PER_INCH ? "dpi" : "dpcm");
 634             }
 635             break;
 636
 637         case IPP_TAG_TEXTLANG :
 638         case IPP_TAG_NAMELANG :
 639         case IPP_TAG_TEXT :
 640         case IPP_TAG_NAME :
 641         case IPP_TAG_KEYWORD :
 642         case IPP_TAG_URI :
 643         case IPP_TAG_URISCHEME :
 644         case IPP_TAG_CHARSET :
 645         case IPP_TAG_LANGUAGE :
 646         case IPP_TAG_MIMETYPE :
 647             for (i = 0; i < count; i ++)
 648               printf("  %s\n", ippGetString(attr, i, NULL));
 649             break;
 650
 651         case IPP_TAG_STRING :
 652             for (i = 0; i < count; i ++)
 653             {
 654               int j, len;
 655               unsigned char *data = ippGetOctetString(attr, i, &len);
 656
 657               fputs("  ", stdout);
 658               for (j = 0; j < len; j ++)
 659               {
 660                 if (data[j] < ' ' || data[j] >= 0x7f)
 661                   printf("<%02X>", data[j]);
 662                 else
 663                   putchar(data[j]);
 664               }
 665               putchar('\n');
 666             }
 667             break;
 668
 669         case IPP_TAG_BOOLEAN :
 670             break;
 671
 672         default :
 673             printf("  %s\n", ippTagString(ippGetValueTag(attr)));
 674             break;
 675       }
 676     }
 677
 678   }
 679   else if (cupsCheckDestSupported(http, dest, dinfo, option, value))
 680     puts("YES");
 681   else
 682     puts("NO");
 683 }
 684
 685
 686 /*
 687  * 'usage()' - Show program usage.
 688  */
 689
 690 static void
 691 usage(const char *arg)                  /* I - Argument for usage message */
 692 {
 693   if (arg)
 694     printf("testdest: Unknown option \"%s\".\n", arg);
 695
 696   puts("Usage:");
 697   puts("  ./testdest name [operation ...]");
 698   puts("  ./testdest ipp://... [operation ...]");
 699   puts("  ./testdest ipps://... [operation ...]");
 700   puts("  ./testdest --enum [grayscale] [color] [duplex] [staple] [small]\n"
 701        "                    [medium] [large]");
 702   puts("");
 703   puts("Operations:");
 704   puts("  conflicts options");
 705   puts("  default option");
 706   puts("  localize option [value]");
 707   puts("  media [borderless] [duplex] [exact] [ready] [name or size]");
 708   puts("  print filename [options]");
 709   puts("  supported [option [value]]");
 710
 711   exit(arg != NULL);
 712 }