cups/util.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   Printing utilities for CUPS.
   5  *
   6  *   Copyright 2007-2013 by Apple Inc.
   7  *   Copyright 1997-2006 by Easy Software Products.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   which should have been included with this file.  If this file is
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  *   This file is subject to the Apple OS-Developed Software exception.
  16  *
  17  * Contents:
  18  *
  19  *   cupsCancelJob()        - Cancel a print job on the default server.
  20  *   cupsCancelJob2()       - Cancel or purge a print job.
  21  *   cupsCreateJob()        - Create an empty job for streaming.
  22  *   cupsFinishDocument()   - Finish sending a document.
  23  *   cupsFreeJobs()         - Free memory used by job data.
  24  *   cupsGetClasses()       - Get a list of printer classes from the default
  25  *                            server.
  26  *   cupsGetDefault()       - Get the default printer or class for the default
  27  *                            server.
  28  *   cupsGetDefault2()      - Get the default printer or class for the specified
  29  *                            server.
  30  *   cupsGetJobs()          - Get the jobs from the default server.
  31  *   cupsGetJobs2()         - Get the jobs from the specified server.
  32  *   cupsGetPPD()           - Get the PPD file for a printer on the default
  33  *                            server.
  34  *   cupsGetPPD2()          - Get the PPD file for a printer from the specified
  35  *                            server.
  36  *   cupsGetPPD3()          - Get the PPD file for a printer on the specified
  37  *                            server if it has changed.
  38  *   cupsGetPrinters()      - Get a list of printers from the default server.
  39  *   cupsGetServerPPD()     - Get an available PPD file from the server.
  40  *   cupsPrintFile()        - Print a file to a printer or class on the default
  41  *                            server.
  42  *   cupsPrintFile2()       - Print a file to a printer or class on the
  43  *                            specified server.
  44  *   cupsPrintFiles()       - Print one or more files to a printer or class on
  45  *                            the default server.
  46  *   cupsPrintFiles2()      - Print one or more files to a printer or class on
  47  *                            the specified server.
  48  *   cupsStartDocument()    - Add a document to a job created with
  49  *                            cupsCreateJob().
  50  *   cups_get_printer_uri() - Get the printer-uri-supported attribute for the
  51  *                            first printer in a class.
  52  */
  53
  54 /*
  55  * Include necessary headers...
  56  */
  57
  58 #include "cups-private.h"
  59 #include <fcntl.h>
  60 #include <sys/stat.h>
  61 #if defined(WIN32) || defined(__EMX__)
  62 #  include <io.h>
  63 #else
  64 #  include <unistd.h>
  65 #endif /* WIN32 || __EMX__ */
  66
  67
  68 /*
  69  * Local functions...
  70  */
  71
  72 static int      cups_get_printer_uri(http_t *http, const char *name,
  73                                      char *host, int hostsize, int *port,
  74                                      char *resource, int resourcesize,
  75                                      int depth);
  76
  77
  78 /*
  79  * 'cupsCancelJob()' - Cancel a print job on the default server.
  80  *
  81  * Pass @code CUPS_JOBID_ALL@ to cancel all jobs or @code CUPS_JOBID_CURRENT@
  82  * to cancel the current job on the named destination.
  83  *
  84  * Use the @link cupsLastError@ and @link cupsLastErrorString@ functions to get
  85  * the cause of any failure.
  86  */
  87
  88 int                                     /* O - 1 on success, 0 on failure */
  89 cupsCancelJob(const char *name,         /* I - Name of printer or class */
  90               int        job_id)        /* I - Job ID, @code CUPS_JOBID_CURRENT@ for the current job, or @code CUPS_JOBID_ALL@ for all jobs */
  91 {
  92   return (cupsCancelJob2(CUPS_HTTP_DEFAULT, name, job_id, 0)
  93               < IPP_STATUS_REDIRECTION_OTHER_SITE);
  94 }
  95
  96
  97 /*
  98  * 'cupsCancelJob2()' - Cancel or purge a print job.
  99  *
 100  * Canceled jobs remain in the job history while purged jobs are removed
 101  * from the job history.
 102  *
 103  * Pass @code CUPS_JOBID_ALL@ to cancel all jobs or @code CUPS_JOBID_CURRENT@
 104  * to cancel the current job on the named destination.
 105  *
 106  * Use the @link cupsLastError@ and @link cupsLastErrorString@ functions to get
 107  * the cause of any failure.
 108  *
 109  * @since CUPS 1.4/OS X 10.6@
 110  */
 111
 112 ipp_status_t                            /* O - IPP status */
 113 cupsCancelJob2(http_t     *http,        /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 114                const char *name,        /* I - Name of printer or class */
 115                int        job_id,       /* I - Job ID, @code CUPS_JOBID_CURRENT@ for the current job, or @code CUPS_JOBID_ALL@ for all jobs */
 116                int        purge)        /* I - 1 to purge, 0 to cancel */
 117 {
 118   char          uri[HTTP_MAX_URI];      /* Job/printer URI */
 119   ipp_t         *request;               /* IPP request */
 120
 121
 122  /*
 123   * Range check input...
 124   */
 125
 126   if (job_id < -1 || (!name && job_id == 0))
 127   {
 128     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 129     return (0);
 130   }
 131
 132  /*
 133   * Connect to the default server as needed...
 134   */
 135
 136   if (!http)
 137     if ((http = _cupsConnect()) == NULL)
 138       return (IPP_STATUS_ERROR_SERVICE_UNAVAILABLE);
 139
 140  /*
 141   * Build an IPP_CANCEL_JOB or IPP_PURGE_JOBS request, which requires the following
 142   * attributes:
 143   *
 144   *    attributes-charset
 145   *    attributes-natural-language
 146   *    job-uri or printer-uri + job-id
 147   *    requesting-user-name
 148   *    [purge-job] or [purge-jobs]
 149   */
 150
 151   request = ippNewRequest(job_id < 0 ? IPP_OP_PURGE_JOBS : IPP_OP_CANCEL_JOB);
 152
 153   if (name)
 154   {
 155     httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 156                      "localhost", ippPort(), "/printers/%s", name);
 157
 158     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
 159                  uri);
 160     ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
 161                   job_id);
 162   }
 163   else if (job_id > 0)
 164   {
 165     snprintf(uri, sizeof(uri), "ipp://localhost/jobs/%d", job_id);
 166
 167     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
 168   }
 169
 170   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 171                NULL, cupsUser());
 172
 173   if (purge && job_id >= 0)
 174     ippAddBoolean(request, IPP_TAG_OPERATION, "purge-job", 1);
 175   else if (!purge && job_id < 0)
 176     ippAddBoolean(request, IPP_TAG_OPERATION, "purge-jobs", 0);
 177
 178  /*
 179   * Do the request...
 180   */
 181
 182   ippDelete(cupsDoRequest(http, request, "/jobs/"));
 183
 184   return (cupsLastError());
 185 }
 186
 187
 188 /*
 189  * 'cupsCreateJob()' - Create an empty job for streaming.
 190  *
 191  * Use this function when you want to stream print data using the
 192  * @link cupsStartDocument@, @link cupsWriteRequestData@, and
 193  * @link cupsFinishDocument@ functions.  If you have one or more files to
 194  * print, use the @link cupsPrintFile2@ or @link cupsPrintFiles2@ function
 195  * instead.
 196  *
 197  * @since CUPS 1.4/OS X 10.6@
 198  */
 199
 200 int                                     /* O - Job ID or 0 on error */
 201 cupsCreateJob(
 202     http_t        *http,                /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 203     const char    *name,                /* I - Destination name */
 204     const char    *title,               /* I - Title of job */
 205     int           num_options,          /* I - Number of options */
 206     cups_option_t *options)             /* I - Options */
 207 {
 208   char          printer_uri[1024],      /* Printer URI */
 209                 resource[1024];         /* Printer resource */
 210   ipp_t         *request,               /* Create-Job request */
 211                 *response;              /* Create-Job response */
 212   ipp_attribute_t *attr;                /* job-id attribute */
 213   int           job_id = 0;             /* job-id value */
 214
 215
 216   DEBUG_printf(("cupsCreateJob(http=%p, name=\"%s\", title=\"%s\", "
 217                 "num_options=%d, options=%p)",
 218                 http, name, title, num_options, options));
 219
 220  /*
 221   * Range check input...
 222   */
 223
 224   if (!name)
 225   {
 226     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 227     return (0);
 228   }
 229
 230  /*
 231   * Build a Create-Job request...
 232   */
 233
 234   if ((request = ippNewRequest(IPP_OP_CREATE_JOB)) == NULL)
 235   {
 236     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
 237     return (0);
 238   }
 239
 240   httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri), "ipp",
 241                    NULL, "localhost", ippPort(), "/printers/%s", name);
 242   snprintf(resource, sizeof(resource), "/printers/%s", name);
 243
 244   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 245                NULL, printer_uri);
 246   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 247                NULL, cupsUser());
 248   if (title)
 249     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
 250                  title);
 251   cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
 252   cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
 253   cupsEncodeOptions2(request, num_options, options, IPP_TAG_SUBSCRIPTION);
 254
 255  /*
 256   * Send the request and get the job-id...
 257   */
 258
 259   response = cupsDoRequest(http, request, resource);
 260
 261   if ((attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) != NULL)
 262     job_id = attr->values[0].integer;
 263
 264   ippDelete(response);
 265
 266  /*
 267   * Return it...
 268   */
 269
 270   return (job_id);
 271 }
 272
 273
 274 /*
 275  * 'cupsFinishDocument()' - Finish sending a document.
 276  *
 277  * The document must have been started using @link cupsStartDocument@.
 278  *
 279  * @since CUPS 1.4/OS X 10.6@
 280  */
 281
 282 ipp_status_t                            /* O - Status of document submission */
 283 cupsFinishDocument(http_t     *http,    /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 284                    const char *name)    /* I - Destination name */
 285 {
 286   char  resource[1024];                 /* Printer resource */
 287
 288
 289   snprintf(resource, sizeof(resource), "/printers/%s", name);
 290
 291   ippDelete(cupsGetResponse(http, resource));
 292
 293   return (cupsLastError());
 294 }
 295
 296
 297 /*
 298  * 'cupsFreeJobs()' - Free memory used by job data.
 299  */
 300
 301 void
 302 cupsFreeJobs(int        num_jobs,       /* I - Number of jobs */
 303              cups_job_t *jobs)          /* I - Jobs */
 304 {
 305   int           i;                      /* Looping var */
 306   cups_job_t    *job;                   /* Current job */
 307
 308
 309   if (num_jobs <= 0 || !jobs)
 310     return;
 311
 312   for (i = num_jobs, job = jobs; i > 0; i --, job ++)
 313   {
 314     _cupsStrFree(job->dest);
 315     _cupsStrFree(job->user);
 316     _cupsStrFree(job->format);
 317     _cupsStrFree(job->title);
 318   }
 319
 320   free(jobs);
 321 }
 322
 323
 324 /*
 325  * 'cupsGetClasses()' - Get a list of printer classes from the default server.
 326  *
 327  * This function is deprecated - use @link cupsGetDests@ instead.
 328  *
 329  * @deprecated@
 330  */
 331
 332 int                                     /* O - Number of classes */
 333 cupsGetClasses(char ***classes)         /* O - Classes */
 334 {
 335   int           n;                      /* Number of classes */
 336   ipp_t         *request,               /* IPP Request */
 337                 *response;              /* IPP Response */
 338   ipp_attribute_t *attr;                /* Current attribute */
 339   char          **temp;                 /* Temporary pointer */
 340   http_t        *http;                  /* Connection to server */
 341
 342
 343   if (!classes)
 344   {
 345     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 346
 347     return (0);
 348   }
 349
 350   *classes = NULL;
 351
 352   if ((http = _cupsConnect()) == NULL)
 353     return (0);
 354
 355  /*
 356   * Build a CUPS_GET_CLASSES request, which requires the following
 357   * attributes:
 358   *
 359   *    attributes-charset
 360   *    attributes-natural-language
 361   *    requested-attributes
 362   */
 363
 364   request = ippNewRequest(IPP_OP_CUPS_GET_CLASSES);
 365
 366   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 367                "requested-attributes", NULL, "printer-name");
 368
 369  /*
 370   * Do the request and get back a response...
 371   */
 372
 373   n = 0;
 374
 375   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 376   {
 377     for (attr = response->attrs; attr != NULL; attr = attr->next)
 378       if (attr->name != NULL &&
 379           _cups_strcasecmp(attr->name, "printer-name") == 0 &&
 380           attr->value_tag == IPP_TAG_NAME)
 381       {
 382         if (n == 0)
 383           temp = malloc(sizeof(char *));
 384         else
 385           temp = realloc(*classes, sizeof(char *) * (n + 1));
 386
 387         if (temp == NULL)
 388         {
 389          /*
 390           * Ran out of memory!
 391           */
 392
 393           while (n > 0)
 394           {
 395             n --;
 396             free((*classes)[n]);
 397           }
 398
 399           free(*classes);
 400           ippDelete(response);
 401           return (0);
 402         }
 403
 404         *classes = temp;
 405         temp[n]  = strdup(attr->values[0].string.text);
 406         n ++;
 407       }
 408
 409     ippDelete(response);
 410   }
 411
 412   return (n);
 413 }
 414
 415
 416 /*
 417  * 'cupsGetDefault()' - Get the default printer or class for the default server.
 418  *
 419  * This function returns the default printer or class as defined by
 420  * the LPDEST or PRINTER environment variables. If these environment
 421  * variables are not set, the server default destination is returned.
 422  * Applications should use the @link cupsGetDests@ and @link cupsGetDest@
 423  * functions to get the user-defined default printer, as this function does
 424  * not support the lpoptions-defined default printer.
 425  */
 426
 427 const char *                            /* O - Default printer or @code NULL@ */
 428 cupsGetDefault(void)
 429 {
 430  /*
 431   * Return the default printer...
 432   */
 433
 434   return (cupsGetDefault2(CUPS_HTTP_DEFAULT));
 435 }
 436
 437
 438 /*
 439  * 'cupsGetDefault2()' - Get the default printer or class for the specified server.
 440  *
 441  * This function returns the default printer or class as defined by
 442  * the LPDEST or PRINTER environment variables. If these environment
 443  * variables are not set, the server default destination is returned.
 444  * Applications should use the @link cupsGetDests@ and @link cupsGetDest@
 445  * functions to get the user-defined default printer, as this function does
 446  * not support the lpoptions-defined default printer.
 447  *
 448  * @since CUPS 1.1.21/OS X 10.4@
 449  */
 450
 451 const char *                            /* O - Default printer or @code NULL@ */
 452 cupsGetDefault2(http_t *http)           /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 453 {
 454   ipp_t         *request,               /* IPP Request */
 455                 *response;              /* IPP Response */
 456   ipp_attribute_t *attr;                /* Current attribute */
 457   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 458
 459
 460  /*
 461   * See if we have a user default printer set...
 462   */
 463
 464   if (_cupsUserDefault(cg->def_printer, sizeof(cg->def_printer)))
 465     return (cg->def_printer);
 466
 467  /*
 468   * Connect to the server as needed...
 469   */
 470
 471   if (!http)
 472     if ((http = _cupsConnect()) == NULL)
 473       return (NULL);
 474
 475  /*
 476   * Build a CUPS_GET_DEFAULT request, which requires the following
 477   * attributes:
 478   *
 479   *    attributes-charset
 480   *    attributes-natural-language
 481   */
 482
 483   request = ippNewRequest(IPP_OP_CUPS_GET_DEFAULT);
 484
 485  /*
 486   * Do the request and get back a response...
 487   */
 488
 489   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 490   {
 491     if ((attr = ippFindAttribute(response, "printer-name",
 492                                  IPP_TAG_NAME)) != NULL)
 493     {
 494       strlcpy(cg->def_printer, attr->values[0].string.text,
 495               sizeof(cg->def_printer));
 496       ippDelete(response);
 497       return (cg->def_printer);
 498     }
 499
 500     ippDelete(response);
 501   }
 502
 503   return (NULL);
 504 }
 505
 506
 507 /*
 508  * 'cupsGetJobs()' - Get the jobs from the default server.
 509  *
 510  * A "whichjobs" value of @code CUPS_WHICHJOBS_ALL@ returns all jobs regardless
 511  * of state, while @code CUPS_WHICHJOBS_ACTIVE@ returns jobs that are
 512  * pending, processing, or held and @code CUPS_WHICHJOBS_COMPLETED@ returns
 513  * jobs that are stopped, canceled, aborted, or completed.
 514  */
 515
 516 int                                     /* O - Number of jobs */
 517 cupsGetJobs(cups_job_t **jobs,          /* O - Job data */
 518             const char *name,           /* I - @code NULL@ = all destinations, otherwise show jobs for named destination */
 519             int        myjobs,          /* I - 0 = all users, 1 = mine */
 520             int        whichjobs)       /* I - @code CUPS_WHICHJOBS_ALL@, @code CUPS_WHICHJOBS_ACTIVE@, or @code CUPS_WHICHJOBS_COMPLETED@ */
 521 {
 522  /*
 523   * Return the jobs...
 524   */
 525
 526   return (cupsGetJobs2(CUPS_HTTP_DEFAULT, jobs, name, myjobs, whichjobs));
 527 }
 528
 529
 530
 531 /*
 532  * 'cupsGetJobs2()' - Get the jobs from the specified server.
 533  *
 534  * A "whichjobs" value of @code CUPS_WHICHJOBS_ALL@ returns all jobs regardless
 535  * of state, while @code CUPS_WHICHJOBS_ACTIVE@ returns jobs that are
 536  * pending, processing, or held and @code CUPS_WHICHJOBS_COMPLETED@ returns
 537  * jobs that are stopped, canceled, aborted, or completed.
 538  *
 539  * @since CUPS 1.1.21/OS X 10.4@
 540  */
 541
 542 int                                     /* O - Number of jobs */
 543 cupsGetJobs2(http_t     *http,          /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 544              cups_job_t **jobs,         /* O - Job data */
 545              const char *name,          /* I - @code NULL@ = all destinations, otherwise show jobs for named destination */
 546              int        myjobs,         /* I - 0 = all users, 1 = mine */
 547              int        whichjobs)      /* I - @code CUPS_WHICHJOBS_ALL@, @code CUPS_WHICHJOBS_ACTIVE@, or @code CUPS_WHICHJOBS_COMPLETED@ */
 548 {
 549   int           n;                      /* Number of jobs */
 550   ipp_t         *request,               /* IPP Request */
 551                 *response;              /* IPP Response */
 552   ipp_attribute_t *attr;                /* Current attribute */
 553   cups_job_t    *temp;                  /* Temporary pointer */
 554   int           id,                     /* job-id */
 555                 priority,               /* job-priority */
 556                 size;                   /* job-k-octets */
 557   ipp_jstate_t  state;                  /* job-state */
 558   time_t        completed_time,         /* time-at-completed */
 559                 creation_time,          /* time-at-creation */
 560                 processing_time;        /* time-at-processing */
 561   const char    *dest,                  /* job-printer-uri */
 562                 *format,                /* document-format */
 563                 *title,                 /* job-name */
 564                 *user;                  /* job-originating-user-name */
 565   char          uri[HTTP_MAX_URI];      /* URI for jobs */
 566   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 567   static const char * const attrs[] =   /* Requested attributes */
 568                 {
 569                   "document-format",
 570                   "job-id",
 571                   "job-k-octets",
 572                   "job-name",
 573                   "job-originating-user-name",
 574                   "job-printer-uri",
 575                   "job-priority",
 576                   "job-state",
 577                   "time-at-completed",
 578                   "time-at-creation",
 579                   "time-at-processing"
 580                 };
 581
 582
 583  /*
 584   * Range check input...
 585   */
 586
 587   if (!jobs)
 588   {
 589     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 590
 591     return (-1);
 592   }
 593
 594  /*
 595   * Get the right URI...
 596   */
 597
 598   if (name)
 599   {
 600     if (httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 601                          "localhost", 0, "/printers/%s",
 602                          name) < HTTP_URI_STATUS_OK)
 603     {
 604       _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
 605                     _("Unable to create printer-uri"), 1);
 606
 607       return (-1);
 608     }
 609   }
 610   else
 611     strlcpy(uri, "ipp://localhost/", sizeof(uri));
 612
 613   if (!http)
 614     if ((http = _cupsConnect()) == NULL)
 615       return (-1);
 616
 617  /*
 618   * Build an IPP_GET_JOBS request, which requires the following
 619   * attributes:
 620   *
 621   *    attributes-charset
 622   *    attributes-natural-language
 623   *    printer-uri
 624   *    requesting-user-name
 625   *    which-jobs
 626   *    my-jobs
 627   *    requested-attributes
 628   */
 629
 630   request = ippNewRequest(IPP_OP_GET_JOBS);
 631
 632   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 633                "printer-uri", NULL, uri);
 634
 635   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 636                "requesting-user-name", NULL, cupsUser());
 637
 638   if (myjobs)
 639     ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
 640
 641   if (whichjobs == CUPS_WHICHJOBS_COMPLETED)
 642     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 643                  "which-jobs", NULL, "completed");
 644   else if (whichjobs == CUPS_WHICHJOBS_ALL)
 645     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 646                  "which-jobs", NULL, "all");
 647
 648   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 649                 "requested-attributes", sizeof(attrs) / sizeof(attrs[0]),
 650                 NULL, attrs);
 651
 652  /*
 653   * Do the request and get back a response...
 654   */
 655
 656   n     = 0;
 657   *jobs = NULL;
 658
 659   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 660   {
 661     for (attr = response->attrs; attr; attr = attr->next)
 662     {
 663      /*
 664       * Skip leading attributes until we hit a job...
 665       */
 666
 667       while (attr && attr->group_tag != IPP_TAG_JOB)
 668         attr = attr->next;
 669
 670       if (!attr)
 671         break;
 672
 673      /*
 674       * Pull the needed attributes from this job...
 675       */
 676
 677       id              = 0;
 678       size            = 0;
 679       priority        = 50;
 680       state           = IPP_JSTATE_PENDING;
 681       user            = "unknown";
 682       dest            = NULL;
 683       format          = "application/octet-stream";
 684       title           = "untitled";
 685       creation_time   = 0;
 686       completed_time  = 0;
 687       processing_time = 0;
 688
 689       while (attr && attr->group_tag == IPP_TAG_JOB)
 690       {
 691         if (!strcmp(attr->name, "job-id") &&
 692             attr->value_tag == IPP_TAG_INTEGER)
 693           id = attr->values[0].integer;
 694         else if (!strcmp(attr->name, "job-state") &&
 695                  attr->value_tag == IPP_TAG_ENUM)
 696           state = (ipp_jstate_t)attr->values[0].integer;
 697         else if (!strcmp(attr->name, "job-priority") &&
 698                  attr->value_tag == IPP_TAG_INTEGER)
 699           priority = attr->values[0].integer;
 700         else if (!strcmp(attr->name, "job-k-octets") &&
 701                  attr->value_tag == IPP_TAG_INTEGER)
 702           size = attr->values[0].integer;
 703         else if (!strcmp(attr->name, "time-at-completed") &&
 704                  attr->value_tag == IPP_TAG_INTEGER)
 705           completed_time = attr->values[0].integer;
 706         else if (!strcmp(attr->name, "time-at-creation") &&
 707                  attr->value_tag == IPP_TAG_INTEGER)
 708           creation_time = attr->values[0].integer;
 709         else if (!strcmp(attr->name, "time-at-processing") &&
 710                  attr->value_tag == IPP_TAG_INTEGER)
 711           processing_time = attr->values[0].integer;
 712         else if (!strcmp(attr->name, "job-printer-uri") &&
 713                  attr->value_tag == IPP_TAG_URI)
 714         {
 715           if ((dest = strrchr(attr->values[0].string.text, '/')) != NULL)
 716             dest ++;
 717         }
 718         else if (!strcmp(attr->name, "job-originating-user-name") &&
 719                  attr->value_tag == IPP_TAG_NAME)
 720           user = attr->values[0].string.text;
 721         else if (!strcmp(attr->name, "document-format") &&
 722                  attr->value_tag == IPP_TAG_MIMETYPE)
 723           format = attr->values[0].string.text;
 724         else if (!strcmp(attr->name, "job-name") &&
 725                  (attr->value_tag == IPP_TAG_TEXT ||
 726                   attr->value_tag == IPP_TAG_NAME))
 727           title = attr->values[0].string.text;
 728
 729         attr = attr->next;
 730       }
 731
 732      /*
 733       * See if we have everything needed...
 734       */
 735
 736       if (!dest || !id)
 737       {
 738         if (!attr)
 739           break;
 740         else
 741           continue;
 742       }
 743
 744      /*
 745       * Allocate memory for the job...
 746       */
 747
 748       if (n == 0)
 749         temp = malloc(sizeof(cups_job_t));
 750       else
 751         temp = realloc(*jobs, sizeof(cups_job_t) * (n + 1));
 752
 753       if (!temp)
 754       {
 755        /*
 756         * Ran out of memory!
 757         */
 758
 759         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
 760
 761         cupsFreeJobs(n, *jobs);
 762         *jobs = NULL;
 763
 764         ippDelete(response);
 765
 766         return (-1);
 767       }
 768
 769       *jobs = temp;
 770       temp  += n;
 771       n ++;
 772
 773      /*
 774       * Copy the data over...
 775       */
 776
 777       temp->dest            = _cupsStrAlloc(dest);
 778       temp->user            = _cupsStrAlloc(user);
 779       temp->format          = _cupsStrAlloc(format);
 780       temp->title           = _cupsStrAlloc(title);
 781       temp->id              = id;
 782       temp->priority        = priority;
 783       temp->state           = state;
 784       temp->size            = size;
 785       temp->completed_time  = completed_time;
 786       temp->creation_time   = creation_time;
 787       temp->processing_time = processing_time;
 788
 789       if (!attr)
 790         break;
 791     }
 792
 793     ippDelete(response);
 794   }
 795
 796   if (n == 0 && cg->last_error >= IPP_STATUS_ERROR_BAD_REQUEST)
 797     return (-1);
 798   else
 799     return (n);
 800 }
 801
 802
 803 /*
 804  * 'cupsGetPPD()' - Get the PPD file for a printer on the default server.
 805  *
 806  * For classes, @code cupsGetPPD@ returns the PPD file for the first printer
 807  * in the class.
 808  *
 809  * The returned filename is stored in a static buffer and is overwritten with
 810  * each call to @code cupsGetPPD@ or @link cupsGetPPD2@.  The caller "owns" the
 811  * file that is created and must @code unlink@ the returned filename.
 812  */
 813
 814 const char *                            /* O - Filename for PPD file */
 815 cupsGetPPD(const char *name)            /* I - Destination name */
 816 {
 817   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 818   time_t        modtime = 0;            /* Modification time */
 819
 820
 821  /*
 822   * Return the PPD file...
 823   */
 824
 825   cg->ppd_filename[0] = '\0';
 826
 827   if (cupsGetPPD3(CUPS_HTTP_DEFAULT, name, &modtime, cg->ppd_filename,
 828                   sizeof(cg->ppd_filename)) == HTTP_STATUS_OK)
 829     return (cg->ppd_filename);
 830   else
 831     return (NULL);
 832 }
 833
 834
 835 /*
 836  * 'cupsGetPPD2()' - Get the PPD file for a printer from the specified server.
 837  *
 838  * For classes, @code cupsGetPPD2@ returns the PPD file for the first printer
 839  * in the class.
 840  *
 841  * The returned filename is stored in a static buffer and is overwritten with
 842  * each call to @link cupsGetPPD@ or @code cupsGetPPD2@.  The caller "owns" the
 843  * file that is created and must @code unlink@ the returned filename.
 844  *
 845  * @since CUPS 1.1.21/OS X 10.4@
 846  */
 847
 848 const char *                            /* O - Filename for PPD file */
 849 cupsGetPPD2(http_t     *http,           /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 850             const char *name)           /* I - Destination name */
 851 {
 852   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 853   time_t        modtime = 0;            /* Modification time */
 854
 855
 856   cg->ppd_filename[0] = '\0';
 857
 858   if (cupsGetPPD3(http, name, &modtime, cg->ppd_filename,
 859                   sizeof(cg->ppd_filename)) == HTTP_STATUS_OK)
 860     return (cg->ppd_filename);
 861   else
 862     return (NULL);
 863 }
 864
 865
 866 /*
 867  * 'cupsGetPPD3()' - Get the PPD file for a printer on the specified
 868  *                   server if it has changed.
 869  *
 870  * The "modtime" parameter contains the modification time of any
 871  * locally-cached content and is updated with the time from the PPD file on
 872  * the server.
 873  *
 874  * The "buffer" parameter contains the local PPD filename.  If it contains
 875  * the empty string, a new temporary file is created, otherwise the existing
 876  * file will be overwritten as needed.  The caller "owns" the file that is
 877  * created and must @code unlink@ the returned filename.
 878  *
 879  * On success, @code HTTP_STATUS_OK@ is returned for a new PPD file and
 880  * @code HTTP_STATUS_NOT_MODIFIED@ if the existing PPD file is up-to-date.  Any other
 881  * status is an error.
 882  *
 883  * For classes, @code cupsGetPPD3@ returns the PPD file for the first printer
 884  * in the class.
 885  *
 886  * @since CUPS 1.4/OS X 10.6@
 887  */
 888
 889 http_status_t                           /* O  - HTTP status */
 890 cupsGetPPD3(http_t     *http,           /* I  - HTTP connection or @code CUPS_HTTP_DEFAULT@ */
 891             const char *name,           /* I  - Destination name */
 892             time_t     *modtime,        /* IO - Modification time */
 893             char       *buffer,         /* I  - Filename buffer */
 894             size_t     bufsize)         /* I  - Size of filename buffer */
 895 {
 896   int           http_port;              /* Port number */
 897   char          http_hostname[HTTP_MAX_HOST];
 898                                         /* Hostname associated with connection */
 899   http_t        *http2;                 /* Alternate HTTP connection */
 900   int           fd;                     /* PPD file */
 901   char          localhost[HTTP_MAX_URI],/* Local hostname */
 902                 hostname[HTTP_MAX_URI], /* Hostname */
 903                 resource[HTTP_MAX_URI]; /* Resource name */
 904   int           port;                   /* Port number */
 905   http_status_t status;                 /* HTTP status from server */
 906   char          tempfile[1024] = "";    /* Temporary filename */
 907   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 908
 909
 910  /*
 911   * Range check input...
 912   */
 913
 914   DEBUG_printf(("cupsGetPPD3(http=%p, name=\"%s\", modtime=%p(%d), buffer=%p, "
 915                 "bufsize=%d)", http, name, modtime,
 916                 modtime ? (int)*modtime : 0, buffer, (int)bufsize));
 917
 918   if (!name)
 919   {
 920     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No printer name"), 1);
 921     return (HTTP_STATUS_NOT_ACCEPTABLE);
 922   }
 923
 924   if (!modtime)
 925   {
 926     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No modification time"), 1);
 927     return (HTTP_STATUS_NOT_ACCEPTABLE);
 928   }
 929
 930   if (!buffer || bufsize <= 1)
 931   {
 932     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Bad filename buffer"), 1);
 933     return (HTTP_STATUS_NOT_ACCEPTABLE);
 934   }
 935
 936 #ifndef WIN32
 937  /*
 938   * See if the PPD file is available locally...
 939   */
 940
 941   if (http)
 942     httpGetHostname(http, hostname, sizeof(hostname));
 943   else
 944   {
 945     strlcpy(hostname, cupsServer(), sizeof(hostname));
 946     if (hostname[0] == '/')
 947       strlcpy(hostname, "localhost", sizeof(hostname));
 948   }
 949
 950   if (!_cups_strcasecmp(hostname, "localhost"))
 951   {
 952     char        ppdname[1024];          /* PPD filename */
 953     struct stat ppdinfo;                /* PPD file information */
 954
 955
 956     snprintf(ppdname, sizeof(ppdname), "%s/ppd/%s.ppd", cg->cups_serverroot,
 957              name);
 958     if (!stat(ppdname, &ppdinfo))
 959     {
 960      /*
 961       * OK, the file exists, use it!
 962       */
 963
 964       if (buffer[0])
 965       {
 966         unlink(buffer);
 967
 968         if (symlink(ppdname, buffer) && errno != EEXIST)
 969         {
 970           _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
 971
 972           return (HTTP_STATUS_SERVER_ERROR);
 973         }
 974       }
 975       else
 976       {
 977         int             tries;          /* Number of tries */
 978         const char      *tmpdir;        /* TMPDIR environment variable */
 979         struct timeval  curtime;        /* Current time */
 980
 981        /*
 982         * Previously we put root temporary files in the default CUPS temporary
 983         * directory under /var/spool/cups.  However, since the scheduler cleans
 984         * out temporary files there and runs independently of the user apps, we
 985         * don't want to use it unless specifically told to by cupsd.
 986         */
 987
 988         if ((tmpdir = getenv("TMPDIR")) == NULL)
 989 #  ifdef __APPLE__
 990           tmpdir = "/private/tmp";      /* /tmp is a symlink to /private/tmp */
 991 #  else
 992           tmpdir = "/tmp";
 993 #  endif /* __APPLE__ */
 994
 995        /*
 996         * Make the temporary name using the specified directory...
 997         */
 998
 999         tries = 0;
1000
1001         do
1002         {
1003          /*
1004           * Get the current time of day...
1005           */
1006
1007           gettimeofday(&curtime, NULL);
1008
1009          /*
1010           * Format a string using the hex time values...
1011           */
1012
1013           snprintf(buffer, bufsize, "%s/%08lx%05lx", tmpdir,
1014                    (unsigned long)curtime.tv_sec,
1015                    (unsigned long)curtime.tv_usec);
1016
1017          /*
1018           * Try to make a symlink...
1019           */
1020
1021           if (!symlink(ppdname, buffer))
1022             break;
1023
1024           tries ++;
1025         }
1026         while (tries < 1000);
1027
1028         if (tries >= 1000)
1029         {
1030           _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
1031
1032           return (HTTP_STATUS_SERVER_ERROR);
1033         }
1034       }
1035
1036       if (*modtime >= ppdinfo.st_mtime)
1037         return (HTTP_STATUS_NOT_MODIFIED);
1038       else
1039       {
1040         *modtime = ppdinfo.st_mtime;
1041         return (HTTP_STATUS_OK);
1042       }
1043     }
1044   }
1045 #endif /* !WIN32 */
1046
1047  /*
1048   * Try finding a printer URI for this printer...
1049   */
1050
1051   if (!http)
1052     if ((http = _cupsConnect()) == NULL)
1053       return (HTTP_STATUS_SERVICE_UNAVAILABLE);
1054
1055   if (!cups_get_printer_uri(http, name, hostname, sizeof(hostname), &port,
1056                             resource, sizeof(resource), 0))
1057     return (HTTP_STATUS_NOT_FOUND);
1058
1059   DEBUG_printf(("2cupsGetPPD3: Printer hostname=\"%s\", port=%d", hostname,
1060                 port));
1061
1062  /*
1063   * Remap local hostname to localhost...
1064   */
1065
1066   httpGetHostname(NULL, localhost, sizeof(localhost));
1067
1068   DEBUG_printf(("2cupsGetPPD3: Local hostname=\"%s\"", localhost));
1069
1070   if (!_cups_strcasecmp(localhost, hostname))
1071     strlcpy(hostname, "localhost", sizeof(hostname));
1072
1073  /*
1074   * Get the hostname and port number we are connected to...
1075   */
1076
1077   httpGetHostname(http, http_hostname, sizeof(http_hostname));
1078   http_port = httpAddrPort(http->hostaddr);
1079
1080   DEBUG_printf(("2cupsGetPPD3: Connection hostname=\"%s\", port=%d",
1081                 http_hostname, http_port));
1082
1083  /*
1084   * Reconnect to the correct server as needed...
1085   */
1086
1087   if (!_cups_strcasecmp(http_hostname, hostname) && port == http_port)
1088     http2 = http;
1089   else if ((http2 = httpConnect2(hostname, port, NULL, AF_UNSPEC,
1090                                  cupsEncryption(), 1, 30000, NULL)) == NULL)
1091   {
1092     DEBUG_puts("1cupsGetPPD3: Unable to connect to server");
1093
1094     return (HTTP_STATUS_SERVICE_UNAVAILABLE);
1095   }
1096
1097  /*
1098   * Get a temp file...
1099   */
1100
1101   if (buffer[0])
1102     fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY, 0600);
1103   else
1104     fd = cupsTempFd(tempfile, sizeof(tempfile));
1105
1106   if (fd < 0)
1107   {
1108    /*
1109     * Can't open file; close the server connection and return NULL...
1110     */
1111
1112     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
1113
1114     if (http2 != http)
1115       httpClose(http2);
1116
1117     return (HTTP_STATUS_SERVER_ERROR);
1118   }
1119
1120  /*
1121   * And send a request to the HTTP server...
1122   */
1123
1124   strlcat(resource, ".ppd", sizeof(resource));
1125
1126   if (*modtime > 0)
1127     httpSetField(http2, HTTP_FIELD_IF_MODIFIED_SINCE,
1128                  httpGetDateString(*modtime));
1129
1130   status = cupsGetFd(http2, resource, fd);
1131
1132   close(fd);
1133
1134  /*
1135   * See if we actually got the file or an error...
1136   */
1137
1138   if (status == HTTP_STATUS_OK)
1139   {
1140     *modtime = httpGetDateTime(httpGetField(http2, HTTP_FIELD_DATE));
1141
1142     if (tempfile[0])
1143       strlcpy(buffer, tempfile, bufsize);
1144   }
1145   else if (status != HTTP_STATUS_NOT_MODIFIED)
1146   {
1147     _cupsSetHTTPError(status);
1148
1149     if (buffer[0])
1150       unlink(buffer);
1151     else if (tempfile[0])
1152       unlink(tempfile);
1153   }
1154   else if (tempfile[0])
1155     unlink(tempfile);
1156
1157   if (http2 != http)
1158     httpClose(http2);
1159
1160  /*
1161   * Return the PPD file...
1162   */
1163
1164   DEBUG_printf(("1cupsGetPPD3: Returning status %d", status));
1165
1166   return (status);
1167 }
1168
1169
1170 /*
1171  * 'cupsGetPrinters()' - Get a list of printers from the default server.
1172  *
1173  * This function is deprecated - use @link cupsGetDests@ instead.
1174  *
1175  * @deprecated@
1176  */
1177
1178 int                                     /* O - Number of printers */
1179 cupsGetPrinters(char ***printers)       /* O - Printers */
1180 {
1181   int           n;                      /* Number of printers */
1182   ipp_t         *request,               /* IPP Request */
1183                 *response;              /* IPP Response */
1184   ipp_attribute_t *attr;                /* Current attribute */
1185   char          **temp;                 /* Temporary pointer */
1186   http_t        *http;                  /* Connection to server */
1187
1188
1189  /*
1190   * Range check input...
1191   */
1192
1193   if (!printers)
1194   {
1195     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
1196
1197     return (0);
1198   }
1199
1200   *printers = NULL;
1201
1202  /*
1203   * Try to connect to the server...
1204   */
1205
1206   if ((http = _cupsConnect()) == NULL)
1207     return (0);
1208
1209  /*
1210   * Build a CUPS_GET_PRINTERS request, which requires the following
1211   * attributes:
1212   *
1213   *    attributes-charset
1214   *    attributes-natural-language
1215   *    requested-attributes
1216   */
1217
1218   request = ippNewRequest(IPP_OP_CUPS_GET_PRINTERS);
1219
1220   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1221                "requested-attributes", NULL, "printer-name");
1222
1223   ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM,
1224                 "printer-type", 0);
1225
1226   ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_ENUM,
1227                 "printer-type-mask", CUPS_PRINTER_CLASS);
1228
1229  /*
1230   * Do the request and get back a response...
1231   */
1232
1233   n = 0;
1234
1235   if ((response = cupsDoRequest(http, request, "/")) != NULL)
1236   {
1237     for (attr = response->attrs; attr != NULL; attr = attr->next)
1238       if (attr->name != NULL &&
1239           _cups_strcasecmp(attr->name, "printer-name") == 0 &&
1240           attr->value_tag == IPP_TAG_NAME)
1241       {
1242         if (n == 0)
1243           temp = malloc(sizeof(char *));
1244         else
1245           temp = realloc(*printers, sizeof(char *) * (n + 1));
1246
1247         if (temp == NULL)
1248         {
1249          /*
1250           * Ran out of memory!
1251           */
1252
1253           while (n > 0)
1254           {
1255             n --;
1256             free((*printers)[n]);
1257           }
1258
1259           free(*printers);
1260           ippDelete(response);
1261           return (0);
1262         }
1263
1264         *printers = temp;
1265         temp[n]   = strdup(attr->values[0].string.text);
1266         n ++;
1267       }
1268
1269     ippDelete(response);
1270   }
1271
1272   return (n);
1273 }
1274
1275
1276 /*
1277  * 'cupsGetServerPPD()' - Get an available PPD file from the server.
1278  *
1279  * This function returns the named PPD file from the server.  The
1280  * list of available PPDs is provided by the IPP @code CUPS_GET_PPDS@
1281  * operation.
1282  *
1283  * You must remove (unlink) the PPD file when you are finished with
1284  * it. The PPD filename is stored in a static location that will be
1285  * overwritten on the next call to @link cupsGetPPD@, @link cupsGetPPD2@,
1286  * or @link cupsGetServerPPD@.
1287  *
1288  * @since CUPS 1.3/OS X 10.5@
1289  */
1290
1291 char *                                  /* O - Name of PPD file or @code NULL@ on error */
1292 cupsGetServerPPD(http_t     *http,      /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
1293                  const char *name)      /* I - Name of PPD file ("ppd-name") */
1294 {
1295   int                   fd;             /* PPD file descriptor */
1296   ipp_t                 *request;       /* IPP request */
1297   _cups_globals_t       *cg = _cupsGlobals();
1298                                         /* Pointer to library globals */
1299
1300
1301  /*
1302   * Range check input...
1303   */
1304
1305   if (!name)
1306   {
1307     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No PPD name"), 1);
1308
1309     return (NULL);
1310   }
1311
1312   if (!http)
1313     if ((http = _cupsConnect()) == NULL)
1314       return (NULL);
1315
1316  /*
1317   * Get a temp file...
1318   */
1319
1320   if ((fd = cupsTempFd(cg->ppd_filename, sizeof(cg->ppd_filename))) < 0)
1321   {
1322    /*
1323     * Can't open file; close the server connection and return NULL...
1324     */
1325
1326     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
1327
1328     return (NULL);
1329   }
1330
1331  /*
1332   * Get the PPD file...
1333   */
1334
1335   request = ippNewRequest(IPP_OP_CUPS_GET_PPD);
1336   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name", NULL,
1337                name);
1338
1339   ippDelete(cupsDoIORequest(http, request, "/", -1, fd));
1340
1341   close(fd);
1342
1343   if (cupsLastError() != IPP_STATUS_OK)
1344   {
1345     unlink(cg->ppd_filename);
1346     return (NULL);
1347   }
1348   else
1349     return (cg->ppd_filename);
1350 }
1351
1352
1353 /*
1354  * 'cupsPrintFile()' - Print a file to a printer or class on the default server.
1355  */
1356
1357 int                                     /* O - Job ID or 0 on error */
1358 cupsPrintFile(const char    *name,      /* I - Destination name */
1359               const char    *filename,  /* I - File to print */
1360               const char    *title,     /* I - Title of job */
1361               int           num_options,/* I - Number of options */
1362               cups_option_t *options)   /* I - Options */
1363 {
1364   DEBUG_printf(("cupsPrintFile(name=\"%s\", filename=\"%s\", "
1365                 "title=\"%s\", num_options=%d, options=%p)",
1366                 name, filename, title, num_options, options));
1367
1368   return (cupsPrintFiles2(CUPS_HTTP_DEFAULT, name, 1, &filename, title,
1369                           num_options, options));
1370 }
1371
1372
1373 /*
1374  * 'cupsPrintFile2()' - Print a file to a printer or class on the specified
1375  *                      server.
1376  *
1377  * @since CUPS 1.1.21/OS X 10.4@
1378  */
1379
1380 int                                     /* O - Job ID or 0 on error */
1381 cupsPrintFile2(
1382     http_t        *http,                /* I - Connection to server */
1383     const char    *name,                /* I - Destination name */
1384     const char    *filename,            /* I - File to print */
1385     const char    *title,               /* I - Title of job */
1386     int           num_options,          /* I - Number of options */
1387     cups_option_t *options)             /* I - Options */
1388 {
1389   DEBUG_printf(("cupsPrintFile2(http=%p, name=\"%s\", filename=\"%s\", "
1390                 "title=\"%s\", num_options=%d, options=%p)",
1391                 http, name, filename, title, num_options, options));
1392
1393   return (cupsPrintFiles2(http, name, 1, &filename, title, num_options,
1394                           options));
1395 }
1396
1397
1398 /*
1399  * 'cupsPrintFiles()' - Print one or more files to a printer or class on the
1400  *                      default server.
1401  */
1402
1403 int                                     /* O - Job ID or 0 on error */
1404 cupsPrintFiles(
1405     const char    *name,                /* I - Destination name */
1406     int           num_files,            /* I - Number of files */
1407     const char    **files,              /* I - File(s) to print */
1408     const char    *title,               /* I - Title of job */
1409     int           num_options,          /* I - Number of options */
1410     cups_option_t *options)             /* I - Options */
1411 {
1412   DEBUG_printf(("cupsPrintFiles(name=\"%s\", num_files=%d, "
1413                 "files=%p, title=\"%s\", num_options=%d, options=%p)",
1414                 name, num_files, files, title, num_options, options));
1415
1416  /*
1417   * Print the file(s)...
1418   */
1419
1420   return (cupsPrintFiles2(CUPS_HTTP_DEFAULT, name, num_files, files, title,
1421                           num_options, options));
1422 }
1423
1424
1425 /*
1426  * 'cupsPrintFiles2()' - Print one or more files to a printer or class on the
1427  *                       specified server.
1428  *
1429  * @since CUPS 1.1.21/OS X 10.4@
1430  */
1431
1432 int                                     /* O - Job ID or 0 on error */
1433 cupsPrintFiles2(
1434     http_t        *http,                /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
1435     const char    *name,                /* I - Destination name */
1436     int           num_files,            /* I - Number of files */
1437     const char    **files,              /* I - File(s) to print */
1438     const char    *title,               /* I - Title of job */
1439     int           num_options,          /* I - Number of options */
1440     cups_option_t *options)             /* I - Options */
1441 {
1442   int           i;                      /* Looping var */
1443   int           job_id;                 /* New job ID */
1444   const char    *docname;               /* Basename of current filename */
1445   const char    *format;                /* Document format */
1446   cups_file_t   *fp;                    /* Current file */
1447   char          buffer[8192];           /* Copy buffer */
1448   ssize_t       bytes;                  /* Bytes in buffer */
1449   http_status_t status;                 /* Status of write */
1450   _cups_globals_t *cg = _cupsGlobals(); /* Global data */
1451   ipp_status_t  cancel_status;          /* Status code to preserve */
1452   char          *cancel_message;        /* Error message to preserve */
1453
1454
1455   DEBUG_printf(("cupsPrintFiles2(http=%p, name=\"%s\", num_files=%d, "
1456                 "files=%p, title=\"%s\", num_options=%d, options=%p)",
1457                 http, name, num_files, files, title, num_options, options));
1458
1459  /*
1460   * Range check input...
1461   */
1462
1463   if (!name || num_files < 1 || !files)
1464   {
1465     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
1466
1467     return (0);
1468   }
1469
1470  /*
1471   * Create the print job...
1472   */
1473
1474   if ((job_id = cupsCreateJob(http, name, title, num_options, options)) == 0)
1475     return (0);
1476
1477  /*
1478   * Send each of the files...
1479   */
1480
1481   if (cupsGetOption("raw", num_options, options))
1482     format = CUPS_FORMAT_RAW;
1483   else if ((format = cupsGetOption("document-format", num_options,
1484                                    options)) == NULL)
1485     format = CUPS_FORMAT_AUTO;
1486
1487   for (i = 0; i < num_files; i ++)
1488   {
1489    /*
1490     * Start the next file...
1491     */
1492
1493     if ((docname = strrchr(files[i], '/')) != NULL)
1494       docname ++;
1495     else
1496       docname = files[i];
1497
1498     if ((fp = cupsFileOpen(files[i], "rb")) == NULL)
1499     {
1500      /*
1501       * Unable to open print file, cancel the job and return...
1502       */
1503
1504       _cupsSetError(IPP_STATUS_ERROR_DOCUMENT_ACCESS, NULL, 0);
1505       goto cancel_job;
1506     }
1507
1508     status = cupsStartDocument(http, name, job_id, docname, format,
1509                                i == (num_files - 1));
1510
1511     while (status == HTTP_STATUS_CONTINUE &&
1512            (bytes = cupsFileRead(fp, buffer, sizeof(buffer))) > 0)
1513       status = cupsWriteRequestData(http, buffer, bytes);
1514
1515     cupsFileClose(fp);
1516
1517     if (status != HTTP_STATUS_CONTINUE || cupsFinishDocument(http, name) != IPP_STATUS_OK)
1518     {
1519      /*
1520       * Unable to queue, cancel the job and return...
1521       */
1522
1523       goto cancel_job;
1524     }
1525   }
1526
1527   return (job_id);
1528
1529  /*
1530   * If we get here, something happened while sending the print job so we need
1531   * to cancel the job without setting the last error (since we need to preserve
1532   * the current error...
1533   */
1534
1535   cancel_job:
1536
1537   cancel_status  = cg->last_error;
1538   cancel_message = cg->last_status_message ?
1539                        _cupsStrRetain(cg->last_status_message) : NULL;
1540
1541   cupsCancelJob2(http, name, job_id, 0);
1542
1543   cg->last_error          = cancel_status;
1544   cg->last_status_message = cancel_message;
1545
1546   return (0);
1547 }
1548
1549
1550 /*
1551  * 'cupsStartDocument()' - Add a document to a job created with cupsCreateJob().
1552  *
1553  * Use @link cupsWriteRequestData@ to write data for the document and
1554  * @link cupsFinishDocument@ to finish the document and get the submission status.
1555  *
1556  * The MIME type constants @code CUPS_FORMAT_AUTO@, @code CUPS_FORMAT_PDF@,
1557  * @code CUPS_FORMAT_POSTSCRIPT@, @code CUPS_FORMAT_RAW@, and
1558  * @code CUPS_FORMAT_TEXT@ are provided for the "format" argument, although
1559  * any supported MIME type string can be supplied.
1560  *
1561  * @since CUPS 1.4/OS X 10.6@
1562  */
1563
1564 http_status_t                           /* O - HTTP status of request */
1565 cupsStartDocument(
1566     http_t     *http,                   /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
1567     const char *name,                   /* I - Destination name */
1568     int        job_id,                  /* I - Job ID from @link cupsCreateJob@ */
1569     const char *docname,                /* I - Name of document */
1570     const char *format,                 /* I - MIME type or @code CUPS_FORMAT_foo@ */
1571     int        last_document)           /* I - 1 for last document in job, 0 otherwise */
1572 {
1573   char          resource[1024],         /* Resource for destinatio */
1574                 printer_uri[1024];      /* Printer URI */
1575   ipp_t         *request;               /* Send-Document request */
1576   http_status_t status;                 /* HTTP status */
1577
1578
1579  /*
1580   * Create a Send-Document request...
1581   */
1582
1583   if ((request = ippNewRequest(IPP_OP_SEND_DOCUMENT)) == NULL)
1584   {
1585     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
1586     return (HTTP_STATUS_ERROR);
1587   }
1588
1589   httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri), "ipp",
1590                    NULL, "localhost", ippPort(), "/printers/%s", name);
1591   snprintf(resource, sizeof(resource), "/printers/%s", name);
1592
1593   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1594                NULL, printer_uri);
1595   ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job_id);
1596   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1597                NULL, cupsUser());
1598   if (docname)
1599     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "document-name",
1600                  NULL, docname);
1601   if (format)
1602     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1603                  "document-format", NULL, format);
1604   ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", last_document);
1605
1606  /*
1607   * Send and delete the request, then return the status...
1608   */
1609
1610   status = cupsSendRequest(http, request, resource, CUPS_LENGTH_VARIABLE);
1611
1612   ippDelete(request);
1613
1614   return (status);
1615 }
1616
1617
1618 /*
1619  * 'cups_get_printer_uri()' - Get the printer-uri-supported attribute for the
1620  *                            first printer in a class.
1621  */
1622
1623 static int                              /* O - 1 on success, 0 on failure */
1624 cups_get_printer_uri(
1625     http_t     *http,                   /* I - Connection to server */
1626     const char *name,                   /* I - Name of printer or class */
1627     char       *host,                   /* I - Hostname buffer */
1628     int        hostsize,                /* I - Size of hostname buffer */
1629     int        *port,                   /* O - Port number */
1630     char       *resource,               /* I - Resource buffer */
1631     int        resourcesize,            /* I - Size of resource buffer */
1632     int        depth)                   /* I - Depth of query */
1633 {
1634   int           i;                      /* Looping var */
1635   int           http_port;              /* Port number */
1636   http_t        *http2;                 /* Alternate HTTP connection */
1637   ipp_t         *request,               /* IPP request */
1638                 *response;              /* IPP response */
1639   ipp_attribute_t *attr;                /* Current attribute */
1640   char          uri[HTTP_MAX_URI],      /* printer-uri attribute */
1641                 scheme[HTTP_MAX_URI],   /* Scheme name */
1642                 username[HTTP_MAX_URI], /* Username:password */
1643                 classname[255],         /* Temporary class name */
1644                 http_hostname[HTTP_MAX_HOST];
1645                                         /* Hostname associated with connection */
1646   static const char * const requested_attrs[] =
1647                 {                       /* Requested attributes */
1648                   "device-uri",
1649                   "member-uris",
1650                   "printer-uri-supported",
1651                   "printer-type"
1652                 };
1653
1654
1655   DEBUG_printf(("7cups_get_printer_uri(http=%p, name=\"%s\", host=%p, "
1656                 "hostsize=%d, resource=%p, resourcesize=%d, depth=%d)",
1657                 http, name, host, hostsize, resource, resourcesize, depth));
1658
1659  /*
1660   * Setup the printer URI...
1661   */
1662
1663   if (httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
1664                        "localhost", 0, "/printers/%s",
1665                        name) < HTTP_URI_STATUS_OK)
1666   {
1667     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unable to create printer-uri"),
1668                   1);
1669
1670     *host     = '\0';
1671     *resource = '\0';
1672
1673     return (0);
1674   }
1675
1676   DEBUG_printf(("9cups_get_printer_uri: printer-uri=\"%s\"", uri));
1677
1678  /*
1679   * Get the hostname and port number we are connected to...
1680   */
1681
1682   httpGetHostname(http, http_hostname, sizeof(http_hostname));
1683   http_port = httpAddrPort(http->hostaddr);
1684
1685  /*
1686   * Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
1687   * attributes:
1688   *
1689   *    attributes-charset
1690   *    attributes-natural-language
1691   *    printer-uri
1692   *    requested-attributes
1693   */
1694
1695   request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
1696
1697   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1698                NULL, uri);
1699
1700   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1701                 "requested-attributes",
1702                 sizeof(requested_attrs) / sizeof(requested_attrs[0]),
1703                 NULL, requested_attrs);
1704
1705  /*
1706   * Do the request and get back a response...
1707   */
1708
1709   snprintf(resource, resourcesize, "/printers/%s", name);
1710
1711   if ((response = cupsDoRequest(http, request, resource)) != NULL)
1712   {
1713     const char *device_uri = NULL;      /* device-uri value */
1714
1715     if ((attr = ippFindAttribute(response, "device-uri",
1716                                  IPP_TAG_URI)) != NULL)
1717       device_uri = attr->values[0].string.text;
1718
1719     if (device_uri &&
1720         (!strncmp(device_uri, "ipp://", 6) ||
1721          !strncmp(device_uri, "ipps://", 7) ||
1722          ((strstr(device_uri, "._ipp.") != NULL ||
1723            strstr(device_uri, "._ipps.") != NULL) &&
1724           !strcmp(device_uri + strlen(device_uri) - 5, "/cups"))))
1725     {
1726      /*
1727       * Statically-configured shared printer.
1728       */
1729
1730       httpSeparateURI(HTTP_URI_CODING_ALL,
1731                       _httpResolveURI(device_uri, uri, sizeof(uri),
1732                                       _HTTP_RESOLVE_DEFAULT, NULL, NULL),
1733                       scheme, sizeof(scheme), username, sizeof(username),
1734                       host, hostsize, port, resource, resourcesize);
1735       ippDelete(response);
1736
1737       return (1);
1738     }
1739     else if ((attr = ippFindAttribute(response, "member-uris",
1740                                       IPP_TAG_URI)) != NULL)
1741     {
1742      /*
1743       * Get the first actual printer name in the class...
1744       */
1745
1746       for (i = 0; i < attr->num_values; i ++)
1747       {
1748         httpSeparateURI(HTTP_URI_CODING_ALL, attr->values[i].string.text,
1749                         scheme, sizeof(scheme), username, sizeof(username),
1750                         host, hostsize, port, resource, resourcesize);
1751         if (!strncmp(resource, "/printers/", 10))
1752         {
1753          /*
1754           * Found a printer!
1755           */
1756
1757           ippDelete(response);
1758
1759           return (1);
1760         }
1761       }
1762
1763      /*
1764       * No printers in this class - try recursively looking for a printer,
1765       * but not more than 3 levels deep...
1766       */
1767
1768       if (depth < 3)
1769       {
1770         for (i = 0; i < attr->num_values; i ++)
1771         {
1772           httpSeparateURI(HTTP_URI_CODING_ALL, attr->values[i].string.text,
1773                           scheme, sizeof(scheme), username, sizeof(username),
1774                           host, hostsize, port, resource, resourcesize);
1775           if (!strncmp(resource, "/classes/", 9))
1776           {
1777            /*
1778             * Found a class!  Connect to the right server...
1779             */
1780
1781             if (!_cups_strcasecmp(http_hostname, host) && *port == http_port)
1782               http2 = http;
1783             else if ((http2 = httpConnect2(host, *port, NULL, AF_UNSPEC,
1784                                            cupsEncryption(), 1, 30000,
1785                                            NULL)) == NULL)
1786             {
1787               DEBUG_puts("8cups_get_printer_uri: Unable to connect to server");
1788
1789               continue;
1790             }
1791
1792            /*
1793             * Look up printers on that server...
1794             */
1795
1796             strlcpy(classname, resource + 9, sizeof(classname));
1797
1798             cups_get_printer_uri(http2, classname, host, hostsize, port,
1799                                  resource, resourcesize, depth + 1);
1800
1801            /*
1802             * Close the connection as needed...
1803             */
1804
1805             if (http2 != http)
1806               httpClose(http2);
1807
1808             if (*host)
1809               return (1);
1810           }
1811         }
1812       }
1813     }
1814     else if ((attr = ippFindAttribute(response, "printer-uri-supported",
1815                                       IPP_TAG_URI)) != NULL)
1816     {
1817       httpSeparateURI(HTTP_URI_CODING_ALL,
1818                       _httpResolveURI(attr->values[0].string.text, uri,
1819                                       sizeof(uri), _HTTP_RESOLVE_DEFAULT,
1820                                       NULL, NULL),
1821                       scheme, sizeof(scheme), username, sizeof(username),
1822                       host, hostsize, port, resource, resourcesize);
1823       ippDelete(response);
1824
1825       if (!strncmp(resource, "/classes/", 9))
1826       {
1827         _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
1828                       _("No printer-uri found for class"), 1);
1829
1830         *host     = '\0';
1831         *resource = '\0';
1832
1833         return (0);
1834       }
1835
1836       return (1);
1837     }
1838
1839     ippDelete(response);
1840   }
1841
1842   if (cupsLastError() != IPP_STATUS_ERROR_NOT_FOUND)
1843     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("No printer-uri found"), 1);
1844
1845   *host     = '\0';
1846   *resource = '\0';
1847
1848   return (0);
1849 }
1850
1851
1852 /*
1853  * End of "$Id$".
1854  */