cups/util.c

   1 /*
   2  * "$Id$"
   3  *
   4  * Printing utilities for CUPS.
   5  *
   6  * Copyright 2007-2015 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
  18 /*
  19  * Include necessary headers...
  20  */
  21
  22 #include "cups-private.h"
  23 #include <fcntl.h>
  24 #include <sys/stat.h>
  25 #if defined(WIN32) || defined(__EMX__)
  26 #  include <io.h>
  27 #else
  28 #  include <unistd.h>
  29 #endif /* WIN32 || __EMX__ */
  30
  31
  32 /*
  33  * 'cupsCancelJob()' - Cancel a print job on the default server.
  34  *
  35  * Pass @code CUPS_JOBID_ALL@ to cancel all jobs or @code CUPS_JOBID_CURRENT@
  36  * to cancel the current job on the named destination.
  37  *
  38  * Use the @link cupsLastError@ and @link cupsLastErrorString@ functions to get
  39  * the cause of any failure.
  40  */
  41
  42 int                                     /* O - 1 on success, 0 on failure */
  43 cupsCancelJob(const char *name,         /* I - Name of printer or class */
  44               int        job_id)        /* I - Job ID, @code CUPS_JOBID_CURRENT@ for the current job, or @code CUPS_JOBID_ALL@ for all jobs */
  45 {
  46   return (cupsCancelJob2(CUPS_HTTP_DEFAULT, name, job_id, 0)
  47               < IPP_STATUS_REDIRECTION_OTHER_SITE);
  48 }
  49
  50
  51 /*
  52  * 'cupsCancelJob2()' - Cancel or purge a print job.
  53  *
  54  * Canceled jobs remain in the job history while purged jobs are removed
  55  * from the job history.
  56  *
  57  * Pass @code CUPS_JOBID_ALL@ to cancel all jobs or @code CUPS_JOBID_CURRENT@
  58  * to cancel the current job on the named destination.
  59  *
  60  * Use the @link cupsLastError@ and @link cupsLastErrorString@ functions to get
  61  * the cause of any failure.
  62  *
  63  * @since CUPS 1.4/OS X 10.6@
  64  */
  65
  66 ipp_status_t                            /* O - IPP status */
  67 cupsCancelJob2(http_t     *http,        /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
  68                const char *name,        /* I - Name of printer or class */
  69                int        job_id,       /* I - Job ID, @code CUPS_JOBID_CURRENT@ for the current job, or @code CUPS_JOBID_ALL@ for all jobs */
  70                int        purge)        /* I - 1 to purge, 0 to cancel */
  71 {
  72   char          uri[HTTP_MAX_URI];      /* Job/printer URI */
  73   ipp_t         *request;               /* IPP request */
  74
  75
  76  /*
  77   * Range check input...
  78   */
  79
  80   if (job_id < -1 || (!name && job_id == 0))
  81   {
  82     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
  83     return (0);
  84   }
  85
  86  /*
  87   * Connect to the default server as needed...
  88   */
  89
  90   if (!http)
  91     if ((http = _cupsConnect()) == NULL)
  92       return (IPP_STATUS_ERROR_SERVICE_UNAVAILABLE);
  93
  94  /*
  95   * Build an IPP_CANCEL_JOB or IPP_PURGE_JOBS request, which requires the following
  96   * attributes:
  97   *
  98   *    attributes-charset
  99   *    attributes-natural-language
 100   *    job-uri or printer-uri + job-id
 101   *    requesting-user-name
 102   *    [purge-job] or [purge-jobs]
 103   */
 104
 105   request = ippNewRequest(job_id < 0 ? IPP_OP_PURGE_JOBS : IPP_OP_CANCEL_JOB);
 106
 107   if (name)
 108   {
 109     httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 110                      "localhost", ippPort(), "/printers/%s", name);
 111
 112     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
 113                  uri);
 114     ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
 115                   job_id);
 116   }
 117   else if (job_id > 0)
 118   {
 119     snprintf(uri, sizeof(uri), "ipp://localhost/jobs/%d", job_id);
 120
 121     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
 122   }
 123
 124   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 125                NULL, cupsUser());
 126
 127   if (purge && job_id >= 0)
 128     ippAddBoolean(request, IPP_TAG_OPERATION, "purge-job", 1);
 129   else if (!purge && job_id < 0)
 130     ippAddBoolean(request, IPP_TAG_OPERATION, "purge-jobs", 0);
 131
 132  /*
 133   * Do the request...
 134   */
 135
 136   ippDelete(cupsDoRequest(http, request, "/jobs/"));
 137
 138   return (cupsLastError());
 139 }
 140
 141
 142 /*
 143  * 'cupsCreateJob()' - Create an empty job for streaming.
 144  *
 145  * Use this function when you want to stream print data using the
 146  * @link cupsStartDocument@, @link cupsWriteRequestData@, and
 147  * @link cupsFinishDocument@ functions.  If you have one or more files to
 148  * print, use the @link cupsPrintFile2@ or @link cupsPrintFiles2@ function
 149  * instead.
 150  *
 151  * @since CUPS 1.4/OS X 10.6@
 152  */
 153
 154 int                                     /* O - Job ID or 0 on error */
 155 cupsCreateJob(
 156     http_t        *http,                /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 157     const char    *name,                /* I - Destination name */
 158     const char    *title,               /* I - Title of job */
 159     int           num_options,          /* I - Number of options */
 160     cups_option_t *options)             /* I - Options */
 161 {
 162   char          printer_uri[1024],      /* Printer URI */
 163                 resource[1024];         /* Printer resource */
 164   ipp_t         *request,               /* Create-Job request */
 165                 *response;              /* Create-Job response */
 166   ipp_attribute_t *attr;                /* job-id attribute */
 167   int           job_id = 0;             /* job-id value */
 168
 169
 170   DEBUG_printf(("cupsCreateJob(http=%p, name=\"%s\", title=\"%s\", "
 171                 "num_options=%d, options=%p)",
 172                 http, name, title, num_options, options));
 173
 174  /*
 175   * Range check input...
 176   */
 177
 178   if (!name)
 179   {
 180     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 181     return (0);
 182   }
 183
 184  /*
 185   * Build a Create-Job request...
 186   */
 187
 188   if ((request = ippNewRequest(IPP_OP_CREATE_JOB)) == NULL)
 189   {
 190     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
 191     return (0);
 192   }
 193
 194   httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri), "ipp",
 195                    NULL, "localhost", ippPort(), "/printers/%s", name);
 196   snprintf(resource, sizeof(resource), "/printers/%s", name);
 197
 198   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 199                NULL, printer_uri);
 200   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 201                NULL, cupsUser());
 202   if (title)
 203     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
 204                  title);
 205   cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
 206   cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
 207   cupsEncodeOptions2(request, num_options, options, IPP_TAG_SUBSCRIPTION);
 208
 209  /*
 210   * Send the request and get the job-id...
 211   */
 212
 213   response = cupsDoRequest(http, request, resource);
 214
 215   if ((attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) != NULL)
 216     job_id = attr->values[0].integer;
 217
 218   ippDelete(response);
 219
 220  /*
 221   * Return it...
 222   */
 223
 224   return (job_id);
 225 }
 226
 227
 228 /*
 229  * 'cupsFinishDocument()' - Finish sending a document.
 230  *
 231  * The document must have been started using @link cupsStartDocument@.
 232  *
 233  * @since CUPS 1.4/OS X 10.6@
 234  */
 235
 236 ipp_status_t                            /* O - Status of document submission */
 237 cupsFinishDocument(http_t     *http,    /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 238                    const char *name)    /* I - Destination name */
 239 {
 240   char  resource[1024];                 /* Printer resource */
 241
 242
 243   snprintf(resource, sizeof(resource), "/printers/%s", name);
 244
 245   ippDelete(cupsGetResponse(http, resource));
 246
 247   return (cupsLastError());
 248 }
 249
 250
 251 /*
 252  * 'cupsFreeJobs()' - Free memory used by job data.
 253  */
 254
 255 void
 256 cupsFreeJobs(int        num_jobs,       /* I - Number of jobs */
 257              cups_job_t *jobs)          /* I - Jobs */
 258 {
 259   int           i;                      /* Looping var */
 260   cups_job_t    *job;                   /* Current job */
 261
 262
 263   if (num_jobs <= 0 || !jobs)
 264     return;
 265
 266   for (i = num_jobs, job = jobs; i > 0; i --, job ++)
 267   {
 268     _cupsStrFree(job->dest);
 269     _cupsStrFree(job->user);
 270     _cupsStrFree(job->format);
 271     _cupsStrFree(job->title);
 272   }
 273
 274   free(jobs);
 275 }
 276
 277
 278 /*
 279  * 'cupsGetClasses()' - Get a list of printer classes from the default server.
 280  *
 281  * This function is deprecated and no longer returns a list of printer
 282  * classes - use @link cupsGetDests@ instead.
 283  *
 284  * @deprecated@
 285  */
 286
 287 int                                     /* O - Number of classes */
 288 cupsGetClasses(char ***classes)         /* O - Classes */
 289 {
 290   if (classes)
 291     *classes = NULL;
 292
 293   return (0);
 294 }
 295
 296
 297 /*
 298  * 'cupsGetDefault()' - Get the default printer or class for the default server.
 299  *
 300  * This function returns the default printer or class as defined by
 301  * the LPDEST or PRINTER environment variables. If these environment
 302  * variables are not set, the server default destination is returned.
 303  * Applications should use the @link cupsGetDests@ and @link cupsGetDest@
 304  * functions to get the user-defined default printer, as this function does
 305  * not support the lpoptions-defined default printer.
 306  */
 307
 308 const char *                            /* O - Default printer or @code NULL@ */
 309 cupsGetDefault(void)
 310 {
 311  /*
 312   * Return the default printer...
 313   */
 314
 315   return (cupsGetDefault2(CUPS_HTTP_DEFAULT));
 316 }
 317
 318
 319 /*
 320  * 'cupsGetDefault2()' - Get the default printer or class for the specified server.
 321  *
 322  * This function returns the default printer or class as defined by
 323  * the LPDEST or PRINTER environment variables. If these environment
 324  * variables are not set, the server default destination is returned.
 325  * Applications should use the @link cupsGetDests@ and @link cupsGetDest@
 326  * functions to get the user-defined default printer, as this function does
 327  * not support the lpoptions-defined default printer.
 328  *
 329  * @since CUPS 1.1.21/OS X 10.4@
 330  */
 331
 332 const char *                            /* O - Default printer or @code NULL@ */
 333 cupsGetDefault2(http_t *http)           /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 334 {
 335   ipp_t         *request,               /* IPP Request */
 336                 *response;              /* IPP Response */
 337   ipp_attribute_t *attr;                /* Current attribute */
 338   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 339
 340
 341  /*
 342   * See if we have a user default printer set...
 343   */
 344
 345   if (_cupsUserDefault(cg->def_printer, sizeof(cg->def_printer)))
 346     return (cg->def_printer);
 347
 348  /*
 349   * Connect to the server as needed...
 350   */
 351
 352   if (!http)
 353     if ((http = _cupsConnect()) == NULL)
 354       return (NULL);
 355
 356  /*
 357   * Build a CUPS_GET_DEFAULT request, which requires the following
 358   * attributes:
 359   *
 360   *    attributes-charset
 361   *    attributes-natural-language
 362   */
 363
 364   request = ippNewRequest(IPP_OP_CUPS_GET_DEFAULT);
 365
 366  /*
 367   * Do the request and get back a response...
 368   */
 369
 370   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 371   {
 372     if ((attr = ippFindAttribute(response, "printer-name",
 373                                  IPP_TAG_NAME)) != NULL)
 374     {
 375       strlcpy(cg->def_printer, attr->values[0].string.text,
 376               sizeof(cg->def_printer));
 377       ippDelete(response);
 378       return (cg->def_printer);
 379     }
 380
 381     ippDelete(response);
 382   }
 383
 384   return (NULL);
 385 }
 386
 387
 388 /*
 389  * 'cupsGetJobs()' - Get the jobs from the default server.
 390  *
 391  * A "whichjobs" value of @code CUPS_WHICHJOBS_ALL@ returns all jobs regardless
 392  * of state, while @code CUPS_WHICHJOBS_ACTIVE@ returns jobs that are
 393  * pending, processing, or held and @code CUPS_WHICHJOBS_COMPLETED@ returns
 394  * jobs that are stopped, canceled, aborted, or completed.
 395  */
 396
 397 int                                     /* O - Number of jobs */
 398 cupsGetJobs(cups_job_t **jobs,          /* O - Job data */
 399             const char *name,           /* I - @code NULL@ = all destinations, otherwise show jobs for named destination */
 400             int        myjobs,          /* I - 0 = all users, 1 = mine */
 401             int        whichjobs)       /* I - @code CUPS_WHICHJOBS_ALL@, @code CUPS_WHICHJOBS_ACTIVE@, or @code CUPS_WHICHJOBS_COMPLETED@ */
 402 {
 403  /*
 404   * Return the jobs...
 405   */
 406
 407   return (cupsGetJobs2(CUPS_HTTP_DEFAULT, jobs, name, myjobs, whichjobs));
 408 }
 409
 410
 411
 412 /*
 413  * 'cupsGetJobs2()' - Get the jobs from the specified server.
 414  *
 415  * A "whichjobs" value of @code CUPS_WHICHJOBS_ALL@ returns all jobs regardless
 416  * of state, while @code CUPS_WHICHJOBS_ACTIVE@ returns jobs that are
 417  * pending, processing, or held and @code CUPS_WHICHJOBS_COMPLETED@ returns
 418  * jobs that are stopped, canceled, aborted, or completed.
 419  *
 420  * @since CUPS 1.1.21/OS X 10.4@
 421  */
 422
 423 int                                     /* O - Number of jobs */
 424 cupsGetJobs2(http_t     *http,          /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 425              cups_job_t **jobs,         /* O - Job data */
 426              const char *name,          /* I - @code NULL@ = all destinations, otherwise show jobs for named destination */
 427              int        myjobs,         /* I - 0 = all users, 1 = mine */
 428              int        whichjobs)      /* I - @code CUPS_WHICHJOBS_ALL@, @code CUPS_WHICHJOBS_ACTIVE@, or @code CUPS_WHICHJOBS_COMPLETED@ */
 429 {
 430   int           n;                      /* Number of jobs */
 431   ipp_t         *request,               /* IPP Request */
 432                 *response;              /* IPP Response */
 433   ipp_attribute_t *attr;                /* Current attribute */
 434   cups_job_t    *temp;                  /* Temporary pointer */
 435   int           id,                     /* job-id */
 436                 priority,               /* job-priority */
 437                 size;                   /* job-k-octets */
 438   ipp_jstate_t  state;                  /* job-state */
 439   time_t        completed_time,         /* time-at-completed */
 440                 creation_time,          /* time-at-creation */
 441                 processing_time;        /* time-at-processing */
 442   const char    *dest,                  /* job-printer-uri */
 443                 *format,                /* document-format */
 444                 *title,                 /* job-name */
 445                 *user;                  /* job-originating-user-name */
 446   char          uri[HTTP_MAX_URI];      /* URI for jobs */
 447   _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */
 448   static const char * const attrs[] =   /* Requested attributes */
 449                 {
 450                   "document-format",
 451                   "job-id",
 452                   "job-k-octets",
 453                   "job-name",
 454                   "job-originating-user-name",
 455                   "job-printer-uri",
 456                   "job-priority",
 457                   "job-state",
 458                   "time-at-completed",
 459                   "time-at-creation",
 460                   "time-at-processing"
 461                 };
 462
 463
 464  /*
 465   * Range check input...
 466   */
 467
 468   if (!jobs)
 469   {
 470     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 471
 472     return (-1);
 473   }
 474
 475  /*
 476   * Get the right URI...
 477   */
 478
 479   if (name)
 480   {
 481     if (httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
 482                          "localhost", 0, "/printers/%s",
 483                          name) < HTTP_URI_STATUS_OK)
 484     {
 485       _cupsSetError(IPP_STATUS_ERROR_INTERNAL,
 486                     _("Unable to create printer-uri"), 1);
 487
 488       return (-1);
 489     }
 490   }
 491   else
 492     strlcpy(uri, "ipp://localhost/", sizeof(uri));
 493
 494   if (!http)
 495     if ((http = _cupsConnect()) == NULL)
 496       return (-1);
 497
 498  /*
 499   * Build an IPP_GET_JOBS request, which requires the following
 500   * attributes:
 501   *
 502   *    attributes-charset
 503   *    attributes-natural-language
 504   *    printer-uri
 505   *    requesting-user-name
 506   *    which-jobs
 507   *    my-jobs
 508   *    requested-attributes
 509   */
 510
 511   request = ippNewRequest(IPP_OP_GET_JOBS);
 512
 513   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
 514                "printer-uri", NULL, uri);
 515
 516   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 517                "requesting-user-name", NULL, cupsUser());
 518
 519   if (myjobs)
 520     ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
 521
 522   if (whichjobs == CUPS_WHICHJOBS_COMPLETED)
 523     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 524                  "which-jobs", NULL, "completed");
 525   else if (whichjobs == CUPS_WHICHJOBS_ALL)
 526     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 527                  "which-jobs", NULL, "all");
 528
 529   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 530                 "requested-attributes", sizeof(attrs) / sizeof(attrs[0]),
 531                 NULL, attrs);
 532
 533  /*
 534   * Do the request and get back a response...
 535   */
 536
 537   n     = 0;
 538   *jobs = NULL;
 539
 540   if ((response = cupsDoRequest(http, request, "/")) != NULL)
 541   {
 542     for (attr = response->attrs; attr; attr = attr->next)
 543     {
 544      /*
 545       * Skip leading attributes until we hit a job...
 546       */
 547
 548       while (attr && attr->group_tag != IPP_TAG_JOB)
 549         attr = attr->next;
 550
 551       if (!attr)
 552         break;
 553
 554      /*
 555       * Pull the needed attributes from this job...
 556       */
 557
 558       id              = 0;
 559       size            = 0;
 560       priority        = 50;
 561       state           = IPP_JSTATE_PENDING;
 562       user            = "unknown";
 563       dest            = NULL;
 564       format          = "application/octet-stream";
 565       title           = "untitled";
 566       creation_time   = 0;
 567       completed_time  = 0;
 568       processing_time = 0;
 569
 570       while (attr && attr->group_tag == IPP_TAG_JOB)
 571       {
 572         if (!strcmp(attr->name, "job-id") &&
 573             attr->value_tag == IPP_TAG_INTEGER)
 574           id = attr->values[0].integer;
 575         else if (!strcmp(attr->name, "job-state") &&
 576                  attr->value_tag == IPP_TAG_ENUM)
 577           state = (ipp_jstate_t)attr->values[0].integer;
 578         else if (!strcmp(attr->name, "job-priority") &&
 579                  attr->value_tag == IPP_TAG_INTEGER)
 580           priority = attr->values[0].integer;
 581         else if (!strcmp(attr->name, "job-k-octets") &&
 582                  attr->value_tag == IPP_TAG_INTEGER)
 583           size = attr->values[0].integer;
 584         else if (!strcmp(attr->name, "time-at-completed") &&
 585                  attr->value_tag == IPP_TAG_INTEGER)
 586           completed_time = attr->values[0].integer;
 587         else if (!strcmp(attr->name, "time-at-creation") &&
 588                  attr->value_tag == IPP_TAG_INTEGER)
 589           creation_time = attr->values[0].integer;
 590         else if (!strcmp(attr->name, "time-at-processing") &&
 591                  attr->value_tag == IPP_TAG_INTEGER)
 592           processing_time = attr->values[0].integer;
 593         else if (!strcmp(attr->name, "job-printer-uri") &&
 594                  attr->value_tag == IPP_TAG_URI)
 595         {
 596           if ((dest = strrchr(attr->values[0].string.text, '/')) != NULL)
 597             dest ++;
 598         }
 599         else if (!strcmp(attr->name, "job-originating-user-name") &&
 600                  attr->value_tag == IPP_TAG_NAME)
 601           user = attr->values[0].string.text;
 602         else if (!strcmp(attr->name, "document-format") &&
 603                  attr->value_tag == IPP_TAG_MIMETYPE)
 604           format = attr->values[0].string.text;
 605         else if (!strcmp(attr->name, "job-name") &&
 606                  (attr->value_tag == IPP_TAG_TEXT ||
 607                   attr->value_tag == IPP_TAG_NAME))
 608           title = attr->values[0].string.text;
 609
 610         attr = attr->next;
 611       }
 612
 613      /*
 614       * See if we have everything needed...
 615       */
 616
 617       if (!dest || !id)
 618       {
 619         if (!attr)
 620           break;
 621         else
 622           continue;
 623       }
 624
 625      /*
 626       * Allocate memory for the job...
 627       */
 628
 629       if (n == 0)
 630         temp = malloc(sizeof(cups_job_t));
 631       else
 632         temp = realloc(*jobs, sizeof(cups_job_t) * (size_t)(n + 1));
 633
 634       if (!temp)
 635       {
 636        /*
 637         * Ran out of memory!
 638         */
 639
 640         _cupsSetError(IPP_STATUS_ERROR_INTERNAL, NULL, 0);
 641
 642         cupsFreeJobs(n, *jobs);
 643         *jobs = NULL;
 644
 645         ippDelete(response);
 646
 647         return (-1);
 648       }
 649
 650       *jobs = temp;
 651       temp  += n;
 652       n ++;
 653
 654      /*
 655       * Copy the data over...
 656       */
 657
 658       temp->dest            = _cupsStrAlloc(dest);
 659       temp->user            = _cupsStrAlloc(user);
 660       temp->format          = _cupsStrAlloc(format);
 661       temp->title           = _cupsStrAlloc(title);
 662       temp->id              = id;
 663       temp->priority        = priority;
 664       temp->state           = state;
 665       temp->size            = size;
 666       temp->completed_time  = completed_time;
 667       temp->creation_time   = creation_time;
 668       temp->processing_time = processing_time;
 669
 670       if (!attr)
 671         break;
 672     }
 673
 674     ippDelete(response);
 675   }
 676
 677   if (n == 0 && cg->last_error >= IPP_STATUS_ERROR_BAD_REQUEST)
 678     return (-1);
 679   else
 680     return (n);
 681 }
 682
 683
 684 /*
 685  * 'cupsGetPrinters()' - Get a list of printers from the default server.
 686  *
 687  * This function is deprecated and no longer returns a list of printers - use
 688  * @link cupsGetDests@ instead.
 689  *
 690  * @deprecated@
 691  */
 692
 693 int                                     /* O - Number of printers */
 694 cupsGetPrinters(char ***printers)       /* O - Printers */
 695 {
 696   if (printers)
 697     *printers = NULL;
 698
 699   return (0);
 700 }
 701
 702
 703 /*
 704  * 'cupsPrintFile()' - Print a file to a printer or class on the default server.
 705  */
 706
 707 int                                     /* O - Job ID or 0 on error */
 708 cupsPrintFile(const char    *name,      /* I - Destination name */
 709               const char    *filename,  /* I - File to print */
 710               const char    *title,     /* I - Title of job */
 711               int           num_options,/* I - Number of options */
 712               cups_option_t *options)   /* I - Options */
 713 {
 714   DEBUG_printf(("cupsPrintFile(name=\"%s\", filename=\"%s\", "
 715                 "title=\"%s\", num_options=%d, options=%p)",
 716                 name, filename, title, num_options, options));
 717
 718   return (cupsPrintFiles2(CUPS_HTTP_DEFAULT, name, 1, &filename, title,
 719                           num_options, options));
 720 }
 721
 722
 723 /*
 724  * 'cupsPrintFile2()' - Print a file to a printer or class on the specified
 725  *                      server.
 726  *
 727  * @since CUPS 1.1.21/OS X 10.4@
 728  */
 729
 730 int                                     /* O - Job ID or 0 on error */
 731 cupsPrintFile2(
 732     http_t        *http,                /* I - Connection to server */
 733     const char    *name,                /* I - Destination name */
 734     const char    *filename,            /* I - File to print */
 735     const char    *title,               /* I - Title of job */
 736     int           num_options,          /* I - Number of options */
 737     cups_option_t *options)             /* I - Options */
 738 {
 739   DEBUG_printf(("cupsPrintFile2(http=%p, name=\"%s\", filename=\"%s\", "
 740                 "title=\"%s\", num_options=%d, options=%p)",
 741                 http, name, filename, title, num_options, options));
 742
 743   return (cupsPrintFiles2(http, name, 1, &filename, title, num_options,
 744                           options));
 745 }
 746
 747
 748 /*
 749  * 'cupsPrintFiles()' - Print one or more files to a printer or class on the
 750  *                      default server.
 751  */
 752
 753 int                                     /* O - Job ID or 0 on error */
 754 cupsPrintFiles(
 755     const char    *name,                /* I - Destination name */
 756     int           num_files,            /* I - Number of files */
 757     const char    **files,              /* I - File(s) to print */
 758     const char    *title,               /* I - Title of job */
 759     int           num_options,          /* I - Number of options */
 760     cups_option_t *options)             /* I - Options */
 761 {
 762   DEBUG_printf(("cupsPrintFiles(name=\"%s\", num_files=%d, "
 763                 "files=%p, title=\"%s\", num_options=%d, options=%p)",
 764                 name, num_files, files, title, num_options, options));
 765
 766  /*
 767   * Print the file(s)...
 768   */
 769
 770   return (cupsPrintFiles2(CUPS_HTTP_DEFAULT, name, num_files, files, title,
 771                           num_options, options));
 772 }
 773
 774
 775 /*
 776  * 'cupsPrintFiles2()' - Print one or more files to a printer or class on the
 777  *                       specified server.
 778  *
 779  * @since CUPS 1.1.21/OS X 10.4@
 780  */
 781
 782 int                                     /* O - Job ID or 0 on error */
 783 cupsPrintFiles2(
 784     http_t        *http,                /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 785     const char    *name,                /* I - Destination name */
 786     int           num_files,            /* I - Number of files */
 787     const char    **files,              /* I - File(s) to print */
 788     const char    *title,               /* I - Title of job */
 789     int           num_options,          /* I - Number of options */
 790     cups_option_t *options)             /* I - Options */
 791 {
 792   int           i;                      /* Looping var */
 793   int           job_id;                 /* New job ID */
 794   const char    *docname;               /* Basename of current filename */
 795   const char    *format;                /* Document format */
 796   cups_file_t   *fp;                    /* Current file */
 797   char          buffer[8192];           /* Copy buffer */
 798   ssize_t       bytes;                  /* Bytes in buffer */
 799   http_status_t status;                 /* Status of write */
 800   _cups_globals_t *cg = _cupsGlobals(); /* Global data */
 801   ipp_status_t  cancel_status;          /* Status code to preserve */
 802   char          *cancel_message;        /* Error message to preserve */
 803
 804
 805   DEBUG_printf(("cupsPrintFiles2(http=%p, name=\"%s\", num_files=%d, "
 806                 "files=%p, title=\"%s\", num_options=%d, options=%p)",
 807                 http, name, num_files, files, title, num_options, options));
 808
 809  /*
 810   * Range check input...
 811   */
 812
 813   if (!name || num_files < 1 || !files)
 814   {
 815     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
 816
 817     return (0);
 818   }
 819
 820  /*
 821   * Create the print job...
 822   */
 823
 824   if ((job_id = cupsCreateJob(http, name, title, num_options, options)) == 0)
 825     return (0);
 826
 827  /*
 828   * Send each of the files...
 829   */
 830
 831   if (cupsGetOption("raw", num_options, options))
 832     format = CUPS_FORMAT_RAW;
 833   else if ((format = cupsGetOption("document-format", num_options,
 834                                    options)) == NULL)
 835     format = CUPS_FORMAT_AUTO;
 836
 837   for (i = 0; i < num_files; i ++)
 838   {
 839    /*
 840     * Start the next file...
 841     */
 842
 843     if ((docname = strrchr(files[i], '/')) != NULL)
 844       docname ++;
 845     else
 846       docname = files[i];
 847
 848     if ((fp = cupsFileOpen(files[i], "rb")) == NULL)
 849     {
 850      /*
 851       * Unable to open print file, cancel the job and return...
 852       */
 853
 854       _cupsSetError(IPP_STATUS_ERROR_DOCUMENT_ACCESS, NULL, 0);
 855       goto cancel_job;
 856     }
 857
 858     status = cupsStartDocument(http, name, job_id, docname, format,
 859                                i == (num_files - 1));
 860
 861     while (status == HTTP_STATUS_CONTINUE &&
 862            (bytes = cupsFileRead(fp, buffer, sizeof(buffer))) > 0)
 863       status = cupsWriteRequestData(http, buffer, (size_t)bytes);
 864
 865     cupsFileClose(fp);
 866
 867     if (status != HTTP_STATUS_CONTINUE || cupsFinishDocument(http, name) != IPP_STATUS_OK)
 868     {
 869      /*
 870       * Unable to queue, cancel the job and return...
 871       */
 872
 873       goto cancel_job;
 874     }
 875   }
 876
 877   return (job_id);
 878
 879  /*
 880   * If we get here, something happened while sending the print job so we need
 881   * to cancel the job without setting the last error (since we need to preserve
 882   * the current error...
 883   */
 884
 885   cancel_job:
 886
 887   cancel_status  = cg->last_error;
 888   cancel_message = cg->last_status_message ?
 889                        _cupsStrRetain(cg->last_status_message) : NULL;
 890
 891   cupsCancelJob2(http, name, job_id, 0);
 892
 893   cg->last_error          = cancel_status;
 894   cg->last_status_message = cancel_message;
 895
 896   return (0);
 897 }
 898
 899
 900 /*
 901  * 'cupsStartDocument()' - Add a document to a job created with cupsCreateJob().
 902  *
 903  * Use @link cupsWriteRequestData@ to write data for the document and
 904  * @link cupsFinishDocument@ to finish the document and get the submission status.
 905  *
 906  * The MIME type constants @code CUPS_FORMAT_AUTO@, @code CUPS_FORMAT_PDF@,
 907  * @code CUPS_FORMAT_POSTSCRIPT@, @code CUPS_FORMAT_RAW@, and
 908  * @code CUPS_FORMAT_TEXT@ are provided for the "format" argument, although
 909  * any supported MIME type string can be supplied.
 910  *
 911  * @since CUPS 1.4/OS X 10.6@
 912  */
 913
 914 http_status_t                           /* O - HTTP status of request */
 915 cupsStartDocument(
 916     http_t     *http,                   /* I - Connection to server or @code CUPS_HTTP_DEFAULT@ */
 917     const char *name,                   /* I - Destination name */
 918     int        job_id,                  /* I - Job ID from @link cupsCreateJob@ */
 919     const char *docname,                /* I - Name of document */
 920     const char *format,                 /* I - MIME type or @code CUPS_FORMAT_foo@ */
 921     int        last_document)           /* I - 1 for last document in job, 0 otherwise */
 922 {
 923   char          resource[1024],         /* Resource for destinatio */
 924                 printer_uri[1024];      /* Printer URI */
 925   ipp_t         *request;               /* Send-Document request */
 926   http_status_t status;                 /* HTTP status */
 927
 928
 929  /*
 930   * Create a Send-Document request...
 931   */
 932
 933   if ((request = ippNewRequest(IPP_OP_SEND_DOCUMENT)) == NULL)
 934   {
 935     _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(ENOMEM), 0);
 936     return (HTTP_STATUS_ERROR);
 937   }
 938
 939   httpAssembleURIf(HTTP_URI_CODING_ALL, printer_uri, sizeof(printer_uri), "ipp",
 940                    NULL, "localhost", ippPort(), "/printers/%s", name);
 941   snprintf(resource, sizeof(resource), "/printers/%s", name);
 942
 943   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 944                NULL, printer_uri);
 945   ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job_id);
 946   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
 947                NULL, cupsUser());
 948   if (docname)
 949     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "document-name",
 950                  NULL, docname);
 951   if (format)
 952     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
 953                  "document-format", NULL, format);
 954   ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", (char)last_document);
 955
 956  /*
 957   * Send and delete the request, then return the status...
 958   */
 959
 960   status = cupsSendRequest(http, request, resource, CUPS_LENGTH_VARIABLE);
 961
 962   ippDelete(request);
 963
 964   return (status);
 965 }
 966
 967
 968 /*
 969  * End of "$Id$".
 970  */