backend/ipp.c

   1 /*
   2  * "$Id: ipp.c 7018 2007-10-10 22:14:03Z mike $"
   3  *
   4  *   IPP backend for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 2007-2008 by Apple Inc.
   7  *   Copyright 1997-2007 by Easy Software Products, all rights reserved.
   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  *   "LICENSE" which should have been included with this file.  If this
  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  *   main()                 - Send a file to the printer or server.
  20  *   cancel_job()           - Cancel a print job.
  21  *   check_printer_state()  - Check the printer state...
  22  *   compress_files()       - Compress print files...
  23  *   password_cb()          - Disable the password prompt for
  24  *                            cupsDoFileRequest().
  25  *   report_printer_state() - Report the printer state.
  26  *   run_pictwps_filter()   - Convert PICT files to PostScript when printing
  27  *                            remotely.
  28  *   sigterm_handler()      - Handle 'terminate' signals that stop the backend.
  29  */
  30
  31 /*
  32  * Include necessary headers.
  33  */
  34
  35 #include <cups/http-private.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <errno.h>
  39 #include <sys/types.h>
  40 #include <sys/stat.h>
  41 #include <cups/backend.h>
  42 #include <cups/cups.h>
  43 #include <cups/language.h>
  44 #include <cups/i18n.h>
  45 #include <cups/string.h>
  46 #include <signal.h>
  47 #include <sys/wait.h>
  48
  49 /*
  50  * Globals...
  51  */
  52
  53 static char     *password = NULL;       /* Password for device URI */
  54 static int      password_tries = 0;     /* Password tries */
  55 #ifdef __APPLE__
  56 static char     pstmpname[1024] = "";   /* Temporary PostScript file name */
  57 #endif /* __APPLE__ */
  58 static char     tmpfilename[1024] = ""; /* Temporary spool file name */
  59 static int      job_cancelled = 0;      /* Job cancelled? */
  60
  61
  62 /*
  63  * Local functions...
  64  */
  65
  66 static void     cancel_job(http_t *http, const char *uri, int id,
  67                            const char *resource, const char *user, int version);
  68 static void     check_printer_state(http_t *http, const char *uri,
  69                                     const char *resource, const char *user,
  70                                     int version, int job_id);
  71 #ifdef HAVE_LIBZ
  72 static void     compress_files(int num_files, char **files);
  73 #endif /* HAVE_LIBZ */
  74 static const char *password_cb(const char *);
  75 static int      report_printer_state(ipp_t *ipp, int job_id);
  76
  77 #ifdef __APPLE__
  78 static int      run_pictwps_filter(char **argv, const char *filename);
  79 #endif /* __APPLE__ */
  80 static void     sigterm_handler(int sig);
  81
  82
  83 /*
  84  * 'main()' - Send a file to the printer or server.
  85  *
  86  * Usage:
  87  *
  88  *    printer-uri job-id user title copies options [file]
  89  */
  90
  91 int                                     /* O - Exit status */
  92 main(int  argc,                         /* I - Number of command-line args */
  93      char *argv[])                      /* I - Command-line arguments */
  94 {
  95   int           i;                      /* Looping var */
  96   int           send_options;           /* Send job options? */
  97   int           num_options;            /* Number of printer options */
  98   cups_option_t *options;               /* Printer options */
  99   char          method[255],            /* Method in URI */
 100                 hostname[1024],         /* Hostname */
 101                 username[255],          /* Username info */
 102                 resource[1024],         /* Resource info (printer name) */
 103                 addrname[256],          /* Address name */
 104                 *optptr,                /* Pointer to URI options */
 105                 *name,                  /* Name of option */
 106                 *value,                 /* Value of option */
 107                 sep;                    /* Separator character */
 108   int           num_files;              /* Number of files to print */
 109   char          **files,                /* Files to print */
 110                 *filename;              /* Pointer to single filename */
 111   int           port;                   /* Port number (not used) */
 112   char          uri[HTTP_MAX_URI];      /* Updated URI without user/pass */
 113   ipp_status_t  ipp_status;             /* Status of IPP request */
 114   http_t        *http;                  /* HTTP connection */
 115   ipp_t         *request,               /* IPP request */
 116                 *response,              /* IPP response */
 117                 *supported;             /* get-printer-attributes response */
 118   time_t        start_time;             /* Time of first connect */
 119   int           recoverable;            /* Recoverable error shown? */
 120   int           contimeout;             /* Connection timeout */
 121   int           delay;                  /* Delay for retries... */
 122   int           compression,            /* Do compression of the job data? */
 123                 waitjob,                /* Wait for job complete? */
 124                 waitprinter;            /* Wait for printer ready? */
 125   ipp_attribute_t *job_id_attr;         /* job-id attribute */
 126   int           job_id;                 /* job-id value */
 127   ipp_attribute_t *job_sheets;          /* job-media-sheets-completed */
 128   ipp_attribute_t *job_state;           /* job-state */
 129   ipp_attribute_t *copies_sup;          /* copies-supported */
 130   ipp_attribute_t *format_sup;          /* document-format-supported */
 131   ipp_attribute_t *printer_state;       /* printer-state attribute */
 132   ipp_attribute_t *printer_accepting;   /* printer-is-accepting-jobs */
 133   int           copies,                 /* Number of copies for job */
 134                 copies_remaining;       /* Number of copies remaining */
 135   const char    *content_type,          /* CONTENT_TYPE environment variable */
 136                 *final_content_type;    /* FINAL_CONTENT_TYPE environment var */
 137 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
 138   struct sigaction action;              /* Actions for POSIX signals */
 139 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
 140   int           version;                /* IPP version */
 141   static const char * const pattrs[] =
 142                 {                       /* Printer attributes we want */
 143                   "copies-supported",
 144                   "document-format-supported",
 145                   "printer-is-accepting-jobs",
 146                   "printer-state",
 147                   "printer-state-message",
 148                   "printer-state-reasons",
 149                 };
 150   static const char * const jattrs[] =
 151                 {                       /* Job attributes we want */
 152                   "job-media-sheets-completed",
 153                   "job-state"
 154                 };
 155
 156
 157  /*
 158   * Make sure status messages are not buffered...
 159   */
 160
 161   setbuf(stderr, NULL);
 162
 163  /*
 164   * Ignore SIGPIPE and catch SIGTERM signals...
 165   */
 166
 167 #ifdef HAVE_SIGSET
 168   sigset(SIGPIPE, SIG_IGN);
 169   sigset(SIGTERM, sigterm_handler);
 170 #elif defined(HAVE_SIGACTION)
 171   memset(&action, 0, sizeof(action));
 172   action.sa_handler = SIG_IGN;
 173   sigaction(SIGPIPE, &action, NULL);
 174
 175   sigemptyset(&action.sa_mask);
 176   sigaddset(&action.sa_mask, SIGTERM);
 177   action.sa_handler = sigterm_handler;
 178   sigaction(SIGTERM, &action, NULL);
 179 #else
 180   signal(SIGPIPE, SIG_IGN);
 181   signal(SIGTERM, sigterm_handler);
 182 #endif /* HAVE_SIGSET */
 183
 184  /*
 185   * Check command-line...
 186   */
 187
 188   if (argc == 1)
 189   {
 190     char *s;
 191
 192     if ((s = strrchr(argv[0], '/')) != NULL)
 193       s ++;
 194     else
 195       s = argv[0];
 196
 197     printf("network %s \"Unknown\" \"Internet Printing Protocol (%s)\"\n",
 198            s, s);
 199     return (CUPS_BACKEND_OK);
 200   }
 201   else if (argc < 6)
 202   {
 203     _cupsLangPrintf(stderr,
 204                     _("Usage: %s job-id user title copies options [file]\n"),
 205                     argv[0]);
 206     return (CUPS_BACKEND_STOP);
 207   }
 208
 209  /*
 210   * Get the (final) content type...
 211   */
 212
 213   if ((content_type = getenv("CONTENT_TYPE")) == NULL)
 214     content_type = "application/octet-stream";
 215
 216   if ((final_content_type = getenv("FINAL_CONTENT_TYPE")) == NULL)
 217   {
 218     final_content_type = content_type;
 219
 220     if (!strncmp(final_content_type, "printer/", 8))
 221       final_content_type = "application/vnd.cups-raw";
 222   }
 223
 224  /*
 225   * Extract the hostname and printer name from the URI...
 226   */
 227
 228   if (httpSeparateURI(HTTP_URI_CODING_ALL, cupsBackendDeviceURI(argv),
 229                       method, sizeof(method), username, sizeof(username),
 230                       hostname, sizeof(hostname), &port,
 231                       resource, sizeof(resource)) < HTTP_URI_OK)
 232   {
 233     _cupsLangPuts(stderr,
 234                   _("ERROR: Missing device URI on command-line and no "
 235                     "DEVICE_URI environment variable!\n"));
 236     return (CUPS_BACKEND_STOP);
 237   }
 238
 239   if (!port)
 240     port = IPP_PORT;                    /* Default to port 631 */
 241
 242   if (!strcmp(method, "https"))
 243     cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
 244   else
 245     cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
 246
 247  /*
 248   * See if there are any options...
 249   */
 250
 251   compression = 0;
 252   version     = 1;
 253   waitjob     = 1;
 254   waitprinter = 1;
 255   contimeout  = 7 * 24 * 60 * 60;
 256
 257   if ((optptr = strchr(resource, '?')) != NULL)
 258   {
 259    /*
 260     * Yup, terminate the device name string and move to the first
 261     * character of the optptr...
 262     */
 263
 264     *optptr++ = '\0';
 265
 266    /*
 267     * Then parse the optptr...
 268     */
 269
 270     while (*optptr)
 271     {
 272      /*
 273       * Get the name...
 274       */
 275
 276       name = optptr;
 277
 278       while (*optptr && *optptr != '=' && *optptr != '+' && *optptr != '&')
 279         optptr ++;
 280
 281       if ((sep = *optptr) != '\0')
 282         *optptr++ = '\0';
 283
 284       if (sep == '=')
 285       {
 286        /*
 287         * Get the value...
 288         */
 289
 290         value = optptr;
 291
 292         while (*optptr && *optptr != '+' && *optptr != '&')
 293           optptr ++;
 294
 295         if (*optptr)
 296           *optptr++ = '\0';
 297       }
 298       else
 299         value = (char *)"";
 300
 301      /*
 302       * Process the option...
 303       */
 304
 305       if (!strcasecmp(name, "waitjob"))
 306       {
 307        /*
 308         * Wait for job completion?
 309         */
 310
 311         waitjob = !strcasecmp(value, "on") ||
 312                   !strcasecmp(value, "yes") ||
 313                   !strcasecmp(value, "true");
 314       }
 315       else if (!strcasecmp(name, "waitprinter"))
 316       {
 317        /*
 318         * Wait for printer idle?
 319         */
 320
 321         waitprinter = !strcasecmp(value, "on") ||
 322                       !strcasecmp(value, "yes") ||
 323                       !strcasecmp(value, "true");
 324       }
 325       else if (!strcasecmp(name, "encryption"))
 326       {
 327        /*
 328         * Enable/disable encryption?
 329         */
 330
 331         if (!strcasecmp(value, "always"))
 332           cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
 333         else if (!strcasecmp(value, "required"))
 334           cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
 335         else if (!strcasecmp(value, "never"))
 336           cupsSetEncryption(HTTP_ENCRYPT_NEVER);
 337         else if (!strcasecmp(value, "ifrequested"))
 338           cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
 339         else
 340         {
 341           _cupsLangPrintf(stderr,
 342                           _("ERROR: Unknown encryption option value \"%s\"!\n"),
 343                           value);
 344         }
 345       }
 346       else if (!strcasecmp(name, "version"))
 347       {
 348         if (!strcmp(value, "1.0"))
 349           version = 0;
 350         else if (!strcmp(value, "1.1"))
 351           version = 1;
 352         else
 353         {
 354           _cupsLangPrintf(stderr,
 355                           _("ERROR: Unknown version option value \"%s\"!\n"),
 356                           value);
 357         }
 358       }
 359 #ifdef HAVE_LIBZ
 360       else if (!strcasecmp(name, "compression"))
 361       {
 362         compression = !strcasecmp(value, "true") ||
 363                       !strcasecmp(value, "yes") ||
 364                       !strcasecmp(value, "on") ||
 365                       !strcasecmp(value, "gzip");
 366       }
 367 #endif /* HAVE_LIBZ */
 368       else if (!strcasecmp(name, "contimeout"))
 369       {
 370        /*
 371         * Set the connection timeout...
 372         */
 373
 374         if (atoi(value) > 0)
 375           contimeout = atoi(value);
 376       }
 377       else
 378       {
 379        /*
 380         * Unknown option...
 381         */
 382
 383         _cupsLangPrintf(stderr,
 384                         _("ERROR: Unknown option \"%s\" with value \"%s\"!\n"),
 385                         name, value);
 386       }
 387     }
 388   }
 389
 390  /*
 391   * If we have 7 arguments, print the file named on the command-line.
 392   * Otherwise, copy stdin to a temporary file and print the temporary
 393   * file.
 394   */
 395
 396   if (argc == 6)
 397   {
 398    /*
 399     * Copy stdin to a temporary file...
 400     */
 401
 402     int         fd;                     /* File descriptor */
 403     cups_file_t *fp;                    /* Temporary file */
 404     char        buffer[8192];           /* Buffer for copying */
 405     int         bytes;                  /* Number of bytes read */
 406
 407
 408     if ((fd = cupsTempFd(tmpfilename, sizeof(tmpfilename))) < 0)
 409     {
 410       perror("ERROR: unable to create temporary file");
 411       return (CUPS_BACKEND_FAILED);
 412     }
 413
 414     if ((fp = cupsFileOpenFd(fd, compression ? "w9" : "w")) == NULL)
 415     {
 416       perror("ERROR: unable to open temporary file");
 417       close(fd);
 418       unlink(tmpfilename);
 419       return (CUPS_BACKEND_FAILED);
 420     }
 421
 422     while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0)
 423       if (cupsFileWrite(fp, buffer, bytes) < bytes)
 424       {
 425         perror("ERROR: unable to write to temporary file");
 426         cupsFileClose(fp);
 427         unlink(tmpfilename);
 428         return (CUPS_BACKEND_FAILED);
 429       }
 430
 431     cupsFileClose(fp);
 432
 433    /*
 434     * Point to the single file from stdin...
 435     */
 436
 437     filename     = tmpfilename;
 438     num_files    = 1;
 439     files        = &filename;
 440     send_options = 0;
 441   }
 442   else
 443   {
 444    /*
 445     * Point to the files on the command-line...
 446     */
 447
 448     num_files    = argc - 6;
 449     files        = argv + 6;
 450     send_options = 1;
 451
 452 #ifdef HAVE_LIBZ
 453     if (compression)
 454       compress_files(num_files, files);
 455 #endif /* HAVE_LIBZ */
 456   }
 457
 458   fprintf(stderr, "DEBUG: %d files to send in job...\n", num_files);
 459
 460  /*
 461   * Set the authentication info, if any...
 462   */
 463
 464   cupsSetPasswordCB(password_cb);
 465
 466   if (username[0])
 467   {
 468    /*
 469     * Use authenticaion information in the device URI...
 470     */
 471
 472     if ((password = strchr(username, ':')) != NULL)
 473       *password++ = '\0';
 474
 475     cupsSetUser(username);
 476   }
 477   else if (!getuid())
 478   {
 479    /*
 480     * Try loading authentication information from the environment.
 481     */
 482
 483     const char *ptr = getenv("AUTH_USERNAME");
 484
 485     if (ptr)
 486       cupsSetUser(ptr);
 487
 488     password = getenv("AUTH_PASSWORD");
 489   }
 490
 491  /*
 492   * Try connecting to the remote server...
 493   */
 494
 495   delay       = 5;
 496   recoverable = 0;
 497   start_time  = time(NULL);
 498
 499   fputs("STATE: +connecting-to-device\n", stderr);
 500
 501   do
 502   {
 503     _cupsLangPrintf(stderr, _("INFO: Connecting to %s on port %d...\n"),
 504                     hostname, port);
 505
 506     if ((http = httpConnectEncrypt(hostname, port, cupsEncryption())) == NULL)
 507     {
 508       if (job_cancelled)
 509         break;
 510
 511       if (getenv("CLASS") != NULL)
 512       {
 513        /*
 514         * If the CLASS environment variable is set, the job was submitted
 515         * to a class and not to a specific queue.  In this case, we want
 516         * to abort immediately so that the job can be requeued on the next
 517         * available printer in the class.
 518         */
 519
 520         _cupsLangPuts(stderr,
 521                       _("INFO: Unable to contact printer, queuing on next "
 522                         "printer in class...\n"));
 523
 524         if (argc == 6 || strcmp(filename, argv[6]))
 525           unlink(filename);
 526
 527        /*
 528         * Sleep 5 seconds to keep the job from requeuing too rapidly...
 529         */
 530
 531         sleep(5);
 532
 533         return (CUPS_BACKEND_FAILED);
 534       }
 535
 536       if (errno == ECONNREFUSED || errno == EHOSTDOWN ||
 537           errno == EHOSTUNREACH)
 538       {
 539         if (contimeout && (time(NULL) - start_time) > contimeout)
 540         {
 541           _cupsLangPuts(stderr, _("ERROR: Printer not responding!\n"));
 542           return (CUPS_BACKEND_FAILED);
 543         }
 544
 545         recoverable = 1;
 546
 547         _cupsLangPrintf(stderr,
 548                         _("WARNING: recoverable: Network host \'%s\' is busy; "
 549                           "will retry in %d seconds...\n"),
 550                         hostname, delay);
 551
 552         sleep(delay);
 553
 554         if (delay < 30)
 555           delay += 5;
 556       }
 557       else if (h_errno)
 558       {
 559         _cupsLangPrintf(stderr, _("ERROR: Unable to locate printer \'%s\'!\n"),
 560                         hostname);
 561         return (CUPS_BACKEND_STOP);
 562       }
 563       else
 564       {
 565         recoverable = 1;
 566
 567         fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
 568         _cupsLangPuts(stderr,
 569                       _("ERROR: recoverable: Unable to connect to printer; will "
 570                         "retry in 30 seconds...\n"));
 571         sleep(30);
 572       }
 573
 574       if (job_cancelled)
 575         break;
 576     }
 577   }
 578   while (http == NULL);
 579
 580   if (job_cancelled)
 581   {
 582     if (argc == 6 || strcmp(filename, argv[6]))
 583       unlink(filename);
 584
 585     return (CUPS_BACKEND_FAILED);
 586   }
 587
 588   fputs("STATE: -connecting-to-device\n", stderr);
 589   _cupsLangPrintf(stderr, _("INFO: Connected to %s...\n"), hostname);
 590
 591 #ifdef AF_INET6
 592   if (http->hostaddr->addr.sa_family == AF_INET6)
 593     fprintf(stderr, "DEBUG: Connected to [%s]:%d (IPv6)...\n",
 594             httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
 595             ntohs(http->hostaddr->ipv6.sin6_port));
 596   else
 597 #endif /* AF_INET6 */
 598     if (http->hostaddr->addr.sa_family == AF_INET)
 599       fprintf(stderr, "DEBUG: Connected to %s:%d (IPv4)...\n",
 600               httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
 601               ntohs(http->hostaddr->ipv4.sin_port));
 602
 603  /*
 604   * Build a URI for the printer and fill the standard IPP attributes for
 605   * an IPP_PRINT_FILE request.  We can't use the URI in argv[0] because it
 606   * might contain username:password information...
 607   */
 608
 609   snprintf(uri, sizeof(uri), "%s://%s:%d%s", method, hostname, port, resource);
 610
 611  /*
 612   * First validate the destination and see if the device supports multiple
 613   * copies.  We have to do this because some IPP servers (e.g. HP JetDirect)
 614   * don't support the copies attribute...
 615   */
 616
 617   copies_sup = NULL;
 618   format_sup = NULL;
 619   supported  = NULL;
 620
 621   do
 622   {
 623    /*
 624     * Build the IPP request...
 625     */
 626
 627     request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
 628     request->request.op.version[1] = version;
 629
 630     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 631                  NULL, uri);
 632
 633     ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 634                   "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
 635                   NULL, pattrs);
 636
 637    /*
 638     * Do the request...
 639     */
 640
 641     fputs("DEBUG: Getting supported attributes...\n", stderr);
 642
 643     if ((supported = cupsDoRequest(http, request, resource)) == NULL)
 644       ipp_status = cupsLastError();
 645     else
 646       ipp_status = supported->request.status.status_code;
 647
 648     if (ipp_status > IPP_OK_CONFLICT)
 649     {
 650       if (ipp_status == IPP_PRINTER_BUSY ||
 651           ipp_status == IPP_SERVICE_UNAVAILABLE)
 652       {
 653         if (contimeout && (time(NULL) - start_time) > contimeout)
 654         {
 655           _cupsLangPuts(stderr, _("ERROR: Printer not responding!\n"));
 656           return (CUPS_BACKEND_FAILED);
 657         }
 658
 659         recoverable = 1;
 660
 661         _cupsLangPrintf(stderr,
 662                         _("WARNING: recoverable: Network host \'%s\' is busy; "
 663                           "will retry in %d seconds...\n"),
 664                         hostname, delay);
 665
 666         report_printer_state(supported, 0);
 667
 668         sleep(delay);
 669
 670         if (delay < 30)
 671           delay += 5;
 672       }
 673       else if ((ipp_status == IPP_BAD_REQUEST ||
 674                 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version == 1)
 675       {
 676        /*
 677         * Switch to IPP/1.0...
 678         */
 679
 680         _cupsLangPuts(stderr,
 681                       _("INFO: Printer does not support IPP/1.1, trying "
 682                         "IPP/1.0...\n"));
 683         version = 0;
 684         httpReconnect(http);
 685       }
 686       else if (ipp_status == IPP_NOT_FOUND)
 687       {
 688         _cupsLangPuts(stderr, _("ERROR: Destination printer does not exist!\n"));
 689
 690         if (supported)
 691           ippDelete(supported);
 692
 693         return (CUPS_BACKEND_STOP);
 694       }
 695       else
 696       {
 697         _cupsLangPrintf(stderr,
 698                         _("ERROR: Unable to get printer status (%s)!\n"),
 699                         cupsLastErrorString());
 700         sleep(10);
 701       }
 702
 703       if (supported)
 704         ippDelete(supported);
 705
 706       continue;
 707     }
 708     else if ((copies_sup = ippFindAttribute(supported, "copies-supported",
 709                                             IPP_TAG_RANGE)) != NULL)
 710     {
 711      /*
 712       * Has the "copies-supported" attribute - does it have an upper
 713       * bound > 1?
 714       */
 715
 716       if (copies_sup->values[0].range.upper <= 1)
 717         copies_sup = NULL; /* No */
 718     }
 719
 720     format_sup = ippFindAttribute(supported, "document-format-supported",
 721                                   IPP_TAG_MIMETYPE);
 722
 723     if (format_sup)
 724     {
 725       fprintf(stderr, "DEBUG: document-format-supported (%d values)\n",
 726               format_sup->num_values);
 727       for (i = 0; i < format_sup->num_values; i ++)
 728         fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
 729                 format_sup->values[i].string.text);
 730     }
 731
 732     report_printer_state(supported, 0);
 733   }
 734   while (ipp_status > IPP_OK_CONFLICT);
 735
 736  /*
 737   * See if the printer is accepting jobs and is not stopped; if either
 738   * condition is true and we are printing to a class, requeue the job...
 739   */
 740
 741   if (getenv("CLASS") != NULL)
 742   {
 743     printer_state     = ippFindAttribute(supported, "printer-state",
 744                                          IPP_TAG_ENUM);
 745     printer_accepting = ippFindAttribute(supported, "printer-is-accepting-jobs",
 746                                          IPP_TAG_BOOLEAN);
 747
 748     if (printer_state == NULL ||
 749         (printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
 750          waitprinter) ||
 751         printer_accepting == NULL ||
 752         !printer_accepting->values[0].boolean)
 753     {
 754      /*
 755       * If the CLASS environment variable is set, the job was submitted
 756       * to a class and not to a specific queue.  In this case, we want
 757       * to abort immediately so that the job can be requeued on the next
 758       * available printer in the class.
 759       */
 760
 761       _cupsLangPuts(stderr,
 762                     _("INFO: Unable to contact printer, queuing on next "
 763                       "printer in class...\n"));
 764
 765       ippDelete(supported);
 766       httpClose(http);
 767
 768       if (argc == 6 || strcmp(filename, argv[6]))
 769         unlink(filename);
 770
 771      /*
 772       * Sleep 5 seconds to keep the job from requeuing too rapidly...
 773       */
 774
 775       sleep(5);
 776
 777       return (CUPS_BACKEND_FAILED);
 778     }
 779   }
 780
 781   if (recoverable)
 782   {
 783    /*
 784     * If we've shown a recoverable error make sure the printer proxies
 785     * have a chance to see the recovered message. Not pretty but
 786     * necessary for now...
 787     */
 788
 789     fputs("INFO: recovered: \n", stderr);
 790     sleep(5);
 791   }
 792
 793  /*
 794   * See if the printer supports multiple copies...
 795   */
 796
 797   copies = atoi(argv[4]);
 798
 799   if (copies_sup || argc < 7)
 800   {
 801     copies_remaining = 1;
 802
 803     if (argc < 7)
 804       copies = 1;
 805   }
 806   else
 807     copies_remaining = copies;
 808
 809  /*
 810   * Then issue the print-job request...
 811   */
 812
 813   job_id  = 0;
 814
 815   while (copies_remaining > 0)
 816   {
 817    /*
 818     * Build the IPP request...
 819     */
 820
 821     if (job_cancelled)
 822       break;
 823
 824     if (num_files > 1)
 825       request = ippNewRequest(IPP_CREATE_JOB);
 826     else
 827       request = ippNewRequest(IPP_PRINT_JOB);
 828
 829     request->request.op.version[1] = version;
 830
 831     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
 832                  NULL, uri);
 833
 834     fprintf(stderr, "DEBUG: printer-uri = \"%s\"\n", uri);
 835
 836     if (argv[2][0])
 837       ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
 838                    "requesting-user-name", NULL, argv[2]);
 839
 840     fprintf(stderr, "DEBUG: requesting-user-name = \"%s\"\n", argv[2]);
 841
 842    /*
 843     * Only add a "job-name" attribute if the remote server supports
 844     * copy generation - some IPP implementations like HP's don't seem
 845     * to like UTF-8 job names (STR #1837)...
 846     */
 847
 848     if (argv[3][0] && copies_sup)
 849       ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
 850                    argv[3]);
 851
 852     fprintf(stderr, "DEBUG: job-name = \"%s\"\n", argv[3]);
 853
 854 #ifdef HAVE_LIBZ
 855     if (compression)
 856       ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
 857                    "compression", NULL, "gzip");
 858 #endif /* HAVE_LIBZ */
 859
 860    /*
 861     * Handle options on the command-line...
 862     */
 863
 864     options     = NULL;
 865     num_options = cupsParseOptions(argv[5], 0, &options);
 866
 867 #ifdef __APPLE__
 868     if (!strcasecmp(final_content_type, "application/pictwps") &&
 869         num_files == 1)
 870     {
 871       if (format_sup != NULL)
 872       {
 873         for (i = 0; i < format_sup->num_values; i ++)
 874           if (!strcasecmp(final_content_type, format_sup->values[i].string.text))
 875             break;
 876       }
 877
 878       if (format_sup == NULL || i >= format_sup->num_values)
 879       {
 880        /*
 881         * Remote doesn't support "application/pictwps" (i.e. it's not MacOS X)
 882         * so convert the document to PostScript...
 883         */
 884
 885         if (run_pictwps_filter(argv, filename))
 886           return (CUPS_BACKEND_FAILED);
 887
 888         filename = pstmpname;
 889
 890        /*
 891         * Change the MIME type to application/postscript and change the
 892         * number of copies to 1...
 893         */
 894
 895         final_content_type = "application/postscript";
 896         copies             = 1;
 897         copies_remaining   = 1;
 898         send_options       = 0;
 899       }
 900     }
 901 #endif /* __APPLE__ */
 902
 903     if (format_sup != NULL)
 904     {
 905       for (i = 0; i < format_sup->num_values; i ++)
 906         if (!strcasecmp(final_content_type, format_sup->values[i].string.text))
 907           break;
 908
 909       if (i < format_sup->num_values)
 910         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
 911                      "document-format", NULL, final_content_type);
 912     }
 913
 914     if (copies_sup && version > 0 && send_options)
 915     {
 916      /*
 917       * Only send options if the destination printer supports the copies
 918       * attribute and IPP/1.1.  This is a hack for the HP and Lexmark
 919       * implementations of IPP, which do not accept extension attributes
 920       * and incorrectly report a client-error-bad-request error instead of
 921       * the successful-ok-unsupported-attributes status.  In short, at least
 922       * some HP and Lexmark implementations of IPP are non-compliant.
 923       */
 924
 925       cupsEncodeOptions(request, num_options, options);
 926
 927       ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies",
 928                     copies);
 929     }
 930
 931     cupsFreeOptions(num_options, options);
 932
 933    /*
 934     * If copies aren't supported, then we are likely dealing with an HP
 935     * JetDirect.  The HP IPP implementation seems to close the connection
 936     * after every request - that is, it does *not* implement HTTP Keep-
 937     * Alive, which is REQUIRED by HTTP/1.1...
 938     */
 939
 940     if (!copies_sup)
 941       httpReconnect(http);
 942
 943    /*
 944     * Do the request...
 945     */
 946
 947     if (num_files > 1)
 948       response = cupsDoRequest(http, request, resource);
 949     else
 950       response = cupsDoFileRequest(http, request, resource, files[0]);
 951
 952     ipp_status = cupsLastError();
 953
 954     if (ipp_status > IPP_OK_CONFLICT)
 955     {
 956       job_id = 0;
 957
 958       if (job_cancelled)
 959         break;
 960
 961       if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
 962           ipp_status == IPP_PRINTER_BUSY)
 963       {
 964         _cupsLangPuts(stderr,
 965                       _("INFO: Printer busy; will retry in 10 seconds...\n"));
 966         sleep(10);
 967       }
 968       else if ((ipp_status == IPP_BAD_REQUEST ||
 969                 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version == 1)
 970       {
 971        /*
 972         * Switch to IPP/1.0...
 973         */
 974
 975         _cupsLangPuts(stderr,
 976                       _("INFO: Printer does not support IPP/1.1, trying "
 977                         "IPP/1.0...\n"));
 978         version = 0;
 979         httpReconnect(http);
 980       }
 981       else
 982         _cupsLangPrintf(stderr, _("ERROR: Print file was not accepted (%s)!\n"),
 983                         cupsLastErrorString());
 984     }
 985     else if ((job_id_attr = ippFindAttribute(response, "job-id",
 986                                              IPP_TAG_INTEGER)) == NULL)
 987     {
 988       _cupsLangPuts(stderr,
 989                     _("NOTICE: Print file accepted - job ID unknown.\n"));
 990       job_id = 0;
 991     }
 992     else
 993     {
 994       job_id = job_id_attr->values[0].integer;
 995       _cupsLangPrintf(stderr, _("NOTICE: Print file accepted - job ID %d.\n"),
 996                       job_id);
 997     }
 998
 999     ippDelete(response);
1000
1001     if (job_cancelled)
1002       break;
1003
1004     if (job_id && num_files > 1)
1005     {
1006       for (i = 0; i < num_files; i ++)
1007       {
1008         request = ippNewRequest(IPP_SEND_DOCUMENT);
1009
1010         request->request.op.version[1] = version;
1011
1012         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1013                      NULL, uri);
1014
1015         ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1016                       job_id);
1017
1018         if (argv[2][0])
1019           ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1020                        "requesting-user-name", NULL, argv[2]);
1021
1022         if ((i + 1) == num_files)
1023           ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
1024
1025         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1026                      "document-format", NULL, content_type);
1027
1028         ippDelete(cupsDoFileRequest(http, request, resource, files[i]));
1029
1030         if (cupsLastError() > IPP_OK_CONFLICT)
1031         {
1032           ipp_status = cupsLastError();
1033
1034           _cupsLangPrintf(stderr,
1035                           _("ERROR: Unable to add file %d to job: %s\n"),
1036                           job_id, cupsLastErrorString());
1037           break;
1038         }
1039       }
1040     }
1041
1042     if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
1043     {
1044       fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
1045       copies_remaining --;
1046     }
1047     else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
1048              ipp_status == IPP_PRINTER_BUSY)
1049       break;
1050     else
1051       copies_remaining --;
1052
1053    /*
1054     * Wait for the job to complete...
1055     */
1056
1057     if (!job_id || !waitjob)
1058       continue;
1059
1060     _cupsLangPuts(stderr, _("INFO: Waiting for job to complete...\n"));
1061
1062     for (delay = 1; !job_cancelled;)
1063     {
1064      /*
1065       * Build an IPP_GET_JOB_ATTRIBUTES request...
1066       */
1067
1068       request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
1069       request->request.op.version[1] = version;
1070
1071       ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1072                    NULL, uri);
1073
1074       ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1075                     job_id);
1076
1077       if (argv[2][0])
1078         ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1079                      "requesting-user-name", NULL, argv[2]);
1080
1081       ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1082                     "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1083                     NULL, jattrs);
1084
1085      /*
1086       * Do the request...
1087       */
1088
1089       if (!copies_sup)
1090         httpReconnect(http);
1091
1092       response   = cupsDoRequest(http, request, resource);
1093       ipp_status = cupsLastError();
1094
1095       if (ipp_status == IPP_NOT_FOUND)
1096       {
1097        /*
1098         * Job has gone away and/or the server has no job history...
1099         */
1100
1101         ippDelete(response);
1102
1103         ipp_status = IPP_OK;
1104         break;
1105       }
1106
1107       if (ipp_status > IPP_OK_CONFLICT)
1108       {
1109         if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
1110             ipp_status != IPP_PRINTER_BUSY)
1111         {
1112           ippDelete(response);
1113
1114           _cupsLangPrintf(stderr,
1115                           _("ERROR: Unable to get job %d attributes (%s)!\n"),
1116                           job_id, cupsLastErrorString());
1117           break;
1118         }
1119       }
1120
1121       if (response)
1122       {
1123         if ((job_state = ippFindAttribute(response, "job-state",
1124                                           IPP_TAG_ENUM)) != NULL)
1125         {
1126          /*
1127           * Stop polling if the job is finished or pending-held...
1128           */
1129
1130           if (job_state->values[0].integer > IPP_JOB_STOPPED)
1131           {
1132             if ((job_sheets = ippFindAttribute(response,
1133                                                "job-media-sheets-completed",
1134                                                IPP_TAG_INTEGER)) != NULL)
1135               fprintf(stderr, "PAGE: total %d\n",
1136                       job_sheets->values[0].integer);
1137
1138             ippDelete(response);
1139             break;
1140           }
1141         }
1142       }
1143
1144       ippDelete(response);
1145
1146      /*
1147       * Check the printer state and report it if necessary...
1148       */
1149
1150       check_printer_state(http, uri, resource, argv[2], version, job_id);
1151
1152      /*
1153       * Wait 1-10 seconds before polling again...
1154       */
1155
1156       sleep(delay);
1157
1158       delay ++;
1159       if (delay > 10)
1160         delay = 1;
1161     }
1162   }
1163
1164  /*
1165   * Cancel the job as needed...
1166   */
1167
1168   if (job_cancelled && job_id)
1169     cancel_job(http, uri, job_id, resource, argv[2], version);
1170
1171  /*
1172   * Check the printer state and report it if necessary...
1173   */
1174
1175   check_printer_state(http, uri, resource, argv[2], version, job_id);
1176
1177  /*
1178   * Free memory...
1179   */
1180
1181   httpClose(http);
1182
1183   ippDelete(supported);
1184
1185  /*
1186   * Remove the temporary file(s) if necessary...
1187   */
1188
1189   if (tmpfilename[0])
1190     unlink(tmpfilename);
1191
1192 #ifdef HAVE_LIBZ
1193   if (compression)
1194   {
1195     for (i = 0; i < num_files; i ++)
1196       unlink(files[i]);
1197   }
1198 #endif /* HAVE_LIBZ */
1199
1200 #ifdef __APPLE__
1201   if (pstmpname[0])
1202     unlink(pstmpname);
1203 #endif /* __APPLE__ */
1204
1205  /*
1206   * Return the queue status...
1207   */
1208
1209   if (ipp_status == IPP_NOT_AUTHORIZED)
1210   {
1211    /*
1212     * Authorization failures here mean that we need Kerberos.  Username +
1213     * password authentication is handled in the password_cb function.
1214     */
1215
1216     fputs("ATTR: auth-info-required=negotiate\n", stderr);
1217     return (CUPS_BACKEND_AUTH_REQUIRED);
1218   }
1219   else if (ipp_status > IPP_OK_CONFLICT)
1220     return (CUPS_BACKEND_FAILED);
1221   else
1222     return (CUPS_BACKEND_OK);
1223 }
1224
1225
1226 /*
1227  * 'cancel_job()' - Cancel a print job.
1228  */
1229
1230 static void
1231 cancel_job(http_t     *http,            /* I - HTTP connection */
1232            const char *uri,             /* I - printer-uri */
1233            int        id,               /* I - job-id */
1234            const char *resource,        /* I - Resource path */
1235            const char *user,            /* I - requesting-user-name */
1236            int        version)          /* I - IPP version */
1237 {
1238   ipp_t *request;                       /* Cancel-Job request */
1239
1240
1241   _cupsLangPuts(stderr, _("INFO: Canceling print job...\n"));
1242
1243   request = ippNewRequest(IPP_CANCEL_JOB);
1244   request->request.op.version[1] = version;
1245
1246   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1247                NULL, uri);
1248   ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id);
1249
1250   if (user && user[0])
1251     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1252                  "requesting-user-name", NULL, user);
1253
1254  /*
1255   * Do the request...
1256   */
1257
1258   ippDelete(cupsDoRequest(http, request, resource));
1259
1260   if (cupsLastError() > IPP_OK_CONFLICT)
1261     _cupsLangPrintf(stderr, _("ERROR: Unable to cancel job %d: %s\n"), id,
1262                     cupsLastErrorString());
1263 }
1264
1265
1266 /*
1267  * 'check_printer_state()' - Check the printer state...
1268  */
1269
1270 static void
1271 check_printer_state(
1272     http_t      *http,                  /* I - HTTP connection */
1273     const char  *uri,                   /* I - Printer URI */
1274     const char  *resource,              /* I - Resource path */
1275     const char  *user,                  /* I - Username, if any */
1276     int         version,                /* I - IPP version */
1277     int         job_id)                 /* I - Current job ID */
1278 {
1279   ipp_t *request,                       /* IPP request */
1280         *response;                      /* IPP response */
1281   static const char * const attrs[] =   /* Attributes we want */
1282   {
1283     "printer-state-message",
1284     "printer-state-reasons"
1285   };
1286
1287
1288  /*
1289   * Check on the printer state...
1290   */
1291
1292   request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
1293   request->request.op.version[1] = version;
1294
1295   ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1296                NULL, uri);
1297
1298   if (user && user[0])
1299     ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1300                  "requesting-user-name", NULL, user);
1301
1302   ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1303                 "requested-attributes",
1304                 (int)(sizeof(attrs) / sizeof(attrs[0])), NULL, attrs);
1305
1306  /*
1307   * Do the request...
1308   */
1309
1310   if ((response = cupsDoRequest(http, request, resource)) != NULL)
1311   {
1312     report_printer_state(response, job_id);
1313     ippDelete(response);
1314   }
1315 }
1316
1317
1318 #ifdef HAVE_LIBZ
1319 /*
1320  * 'compress_files()' - Compress print files...
1321  */
1322
1323 static void
1324 compress_files(int  num_files,          /* I - Number of files */
1325                char **files)            /* I - Files */
1326 {
1327   int           i,                      /* Looping var */
1328                 fd;                     /* Temporary file descriptor */
1329   ssize_t       bytes;                  /* Bytes read/written */
1330   size_t        total;                  /* Total bytes read */
1331   cups_file_t   *in,                    /* Input file */
1332                 *out;                   /* Output file */
1333   struct stat   outinfo;                /* Output file information */
1334   char          filename[1024],         /* Temporary filename */
1335                 buffer[32768];          /* Copy buffer */
1336
1337
1338   fprintf(stderr, "DEBUG: Compressing %d job files...\n", num_files);
1339   for (i = 0; i < num_files; i ++)
1340   {
1341     if ((fd = cupsTempFd(filename, sizeof(filename))) < 0)
1342     {
1343       _cupsLangPrintf(stderr,
1344                       _("ERROR: Unable to create temporary compressed print "
1345                         "file: %s\n"), strerror(errno));
1346       exit(CUPS_BACKEND_FAILED);
1347     }
1348
1349     if ((out = cupsFileOpenFd(fd, "w9")) == NULL)
1350     {
1351       _cupsLangPrintf(stderr,
1352                       _("ERROR: Unable to open temporary compressed print "
1353                         "file: %s\n"), strerror(errno));
1354       exit(CUPS_BACKEND_FAILED);
1355     }
1356
1357     if ((in = cupsFileOpen(files[i], "r")) == NULL)
1358     {
1359       _cupsLangPrintf(stderr,
1360                       _("ERROR: Unable to open print file \"%s\": %s\n"),
1361                       files[i], strerror(errno));
1362       cupsFileClose(out);
1363       exit(CUPS_BACKEND_FAILED);
1364     }
1365
1366     total = 0;
1367     while ((bytes = cupsFileRead(in, buffer, sizeof(buffer))) > 0)
1368       if (cupsFileWrite(out, buffer, bytes) < bytes)
1369       {
1370         _cupsLangPrintf(stderr,
1371                         _("ERROR: Unable to write %d bytes to \"%s\": %s\n"),
1372                         (int)bytes, filename, strerror(errno));
1373         cupsFileClose(in);
1374         cupsFileClose(out);
1375         exit(CUPS_BACKEND_FAILED);
1376       }
1377       else
1378         total += bytes;
1379
1380     cupsFileClose(out);
1381     cupsFileClose(in);
1382
1383     files[i] = strdup(filename);
1384
1385     if (!stat(filename, &outinfo))
1386       fprintf(stderr,
1387               "DEBUG: File %d compressed to %.1f%% of original size, "
1388               CUPS_LLFMT " bytes...\n",
1389               i + 1, 100.0 * outinfo.st_size / total,
1390               CUPS_LLCAST outinfo.st_size);
1391   }
1392 }
1393 #endif /* HAVE_LIBZ */
1394
1395
1396 /*
1397  * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
1398  */
1399
1400 static const char *                     /* O - Password  */
1401 password_cb(const char *prompt)         /* I - Prompt (not used) */
1402 {
1403   (void)prompt;
1404
1405   if (password && password_tries < 3)
1406   {
1407     password_tries ++;
1408
1409     return (password);
1410   }
1411   else
1412   {
1413    /*
1414     * If there is no password set in the device URI, return the
1415     * "authentication required" exit code...
1416     */
1417
1418     if (tmpfilename[0])
1419       unlink(tmpfilename);
1420
1421 #ifdef __APPLE__
1422     if (pstmpname[0])
1423       unlink(pstmpname);
1424 #endif /* __APPLE__ */
1425
1426     fputs("ATTR: auth-info-required=username,password\n", stderr);
1427
1428     exit(CUPS_BACKEND_AUTH_REQUIRED);
1429
1430     return (NULL);                      /* Eliminate compiler warning */
1431   }
1432 }
1433
1434
1435 /*
1436  * 'report_printer_state()' - Report the printer state.
1437  */
1438
1439 static int                              /* O - Number of reasons shown */
1440 report_printer_state(ipp_t *ipp,        /* I - IPP response */
1441                      int   job_id)      /* I - Current job ID */
1442 {
1443   int                   i;              /* Looping var */
1444   int                   count;          /* Count of reasons shown... */
1445   ipp_attribute_t       *psm,           /* pritner-state-message */
1446                         *reasons;       /* printer-state-reasons */
1447   const char            *reason;        /* Current reason */
1448   const char            *message;       /* Message to show */
1449   char                  unknown[1024];  /* Unknown message string */
1450   const char            *prefix;        /* Prefix for STATE: line */
1451   char                  state[1024];    /* State string */
1452   cups_lang_t           *language;      /* Current localization */
1453
1454
1455   if ((psm = ippFindAttribute(ipp, "printer-state-message",
1456                               IPP_TAG_TEXT)) != NULL)
1457     fprintf(stderr, "INFO: %s\n", psm->values[0].string.text);
1458
1459   if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
1460                                   IPP_TAG_KEYWORD)) == NULL)
1461     return (0);
1462
1463   state[0] = '\0';
1464   prefix   = "STATE: ";
1465   language = cupsLangDefault();
1466
1467   for (i = 0, count = 0; i < reasons->num_values; i ++)
1468   {
1469     reason = reasons->values[i].string.text;
1470
1471     if (job_id == 0 || strcmp(reason, "paused"))
1472     {
1473       strlcat(state, prefix, sizeof(state));
1474       strlcat(state, reason, sizeof(state));
1475
1476       prefix  = ",";
1477     }
1478
1479     message = "";
1480
1481     if (!strncmp(reason, "media-needed", 12))
1482       message = _("Media tray needs to be filled.");
1483     else if (!strncmp(reason, "media-jam", 9))
1484       message = _("Media jam!");
1485     else if (!strncmp(reason, "moving-to-paused", 16) ||
1486              !strncmp(reason, "paused", 6) ||
1487              !strncmp(reason, "shutdown", 8))
1488       message = _("Printer off-line.");
1489     else if (!strncmp(reason, "toner-low", 9))
1490       message = _("Toner low.");
1491     else if (!strncmp(reason, "toner-empty", 11))
1492       message = _("Out of toner!");
1493     else if (!strncmp(reason, "cover-open", 10))
1494       message = _("Cover open.");
1495     else if (!strncmp(reason, "interlock-open", 14))
1496       message = _("Interlock open.");
1497     else if (!strncmp(reason, "door-open", 9))
1498       message = _("Door open.");
1499     else if (!strncmp(reason, "input-tray-missing", 18))
1500       message = _("Media tray missing!");
1501     else if (!strncmp(reason, "media-low", 9))
1502       message = _("Media tray almost empty.");
1503     else if (!strncmp(reason, "media-empty", 11))
1504       message = _("Media tray empty!");
1505     else if (!strncmp(reason, "output-tray-missing", 19))
1506       message = _("Output tray missing!");
1507     else if (!strncmp(reason, "output-area-almost-full", 23))
1508       message = _("Output bin almost full.");
1509     else if (!strncmp(reason, "output-area-full", 16))
1510       message = _("Output bin full!");
1511     else if (!strncmp(reason, "marker-supply-low", 17))
1512       message = _("Ink/toner almost empty.");
1513     else if (!strncmp(reason, "marker-supply-empty", 19))
1514       message = _("Ink/toner empty!");
1515     else if (!strncmp(reason, "marker-waste-almost-full", 24))
1516       message = _("Ink/toner waste bin almost full.");
1517     else if (!strncmp(reason, "marker-waste-full", 17))
1518       message = _("Ink/toner waste bin full!");
1519     else if (!strncmp(reason, "fuser-over-temp", 15))
1520       message = _("Fuser temperature high!");
1521     else if (!strncmp(reason, "fuser-under-temp", 16))
1522       message = _("Fuser temperature low!");
1523     else if (!strncmp(reason, "opc-near-eol", 12))
1524       message = _("OPC almost at end-of-life.");
1525     else if (!strncmp(reason, "opc-life-over", 13))
1526       message = _("OPC at end-of-life!");
1527     else if (!strncmp(reason, "developer-low", 13))
1528       message = _("Developer almost empty.");
1529     else if (!strncmp(reason, "developer-empty", 15))
1530       message = _("Developer empty!");
1531     else if (strstr(reason, "error") != NULL)
1532     {
1533       message = unknown;
1534
1535       snprintf(unknown, sizeof(unknown), _("Unknown printer error (%s)!"),
1536                reason);
1537     }
1538
1539     if (message[0])
1540     {
1541       count ++;
1542       if (strstr(reasons->values[i].string.text, "error"))
1543         fprintf(stderr, "ERROR: %s\n", _cupsLangString(language, message));
1544       else if (strstr(reasons->values[i].string.text, "warning"))
1545         fprintf(stderr, "WARNING: %s\n", _cupsLangString(language, message));
1546       else
1547         fprintf(stderr, "INFO: %s\n", _cupsLangString(language, message));
1548     }
1549   }
1550
1551   fprintf(stderr, "%s\n", state);
1552
1553   return (count);
1554 }
1555
1556
1557 #ifdef __APPLE__
1558 /*
1559  * 'run_pictwps_filter()' - Convert PICT files to PostScript when printing
1560  *                          remotely.
1561  *
1562  * This step is required because the PICT format is not documented and
1563  * subject to change, so developing a filter for other OS's is infeasible.
1564  * Also, fonts required by the PICT file need to be embedded on the
1565  * client side (which has the fonts), so we run the filter to get a
1566  * PostScript file for printing...
1567  */
1568
1569 static int                              /* O - Exit status of filter */
1570 run_pictwps_filter(char       **argv,   /* I - Command-line arguments */
1571                    const char *filename)/* I - Filename */
1572 {
1573   struct stat   fileinfo;               /* Print file information */
1574   const char    *ppdfile;               /* PPD file for destination printer */
1575   int           pid;                    /* Child process ID */
1576   int           fd;                     /* Temporary file descriptor */
1577   int           status;                 /* Exit status of filter */
1578   const char    *printer;               /* PRINTER env var */
1579   static char   ppdenv[1024];           /* PPD environment variable */
1580
1581
1582  /*
1583   * First get the PPD file for the printer...
1584   */
1585
1586   printer = getenv("PRINTER");
1587   if (!printer)
1588   {
1589     _cupsLangPuts(stderr,
1590                   _("ERROR: PRINTER environment variable not defined!\n"));
1591     return (-1);
1592   }
1593
1594   if ((ppdfile = cupsGetPPD(printer)) == NULL)
1595   {
1596     _cupsLangPrintf(stderr,
1597                     _("ERROR: Unable to get PPD file for printer \"%s\" - "
1598                       "%s.\n"), printer, cupsLastErrorString());
1599   }
1600   else
1601   {
1602     snprintf(ppdenv, sizeof(ppdenv), "PPD=%s", ppdfile);
1603     putenv(ppdenv);
1604   }
1605
1606  /*
1607   * Then create a temporary file for printing...
1608   */
1609
1610   if ((fd = cupsTempFd(pstmpname, sizeof(pstmpname))) < 0)
1611   {
1612     _cupsLangPrintf(stderr, _("ERROR: Unable to create temporary file - %s.\n"),
1613                     strerror(errno));
1614     if (ppdfile)
1615       unlink(ppdfile);
1616     return (-1);
1617   }
1618
1619  /*
1620   * Get the owner of the spool file - it is owned by the user we want to run
1621   * as...
1622   */
1623
1624   if (argv[6])
1625     stat(argv[6], &fileinfo);
1626   else
1627   {
1628    /*
1629     * Use the OSX defaults, as an up-stream filter created the PICT
1630     * file...
1631     */
1632
1633     fileinfo.st_uid = 1;
1634     fileinfo.st_gid = 80;
1635   }
1636
1637   if (ppdfile)
1638     chown(ppdfile, fileinfo.st_uid, fileinfo.st_gid);
1639
1640   fchown(fd, fileinfo.st_uid, fileinfo.st_gid);
1641
1642  /*
1643   * Finally, run the filter to convert the file...
1644   */
1645
1646   if ((pid = fork()) == 0)
1647   {
1648    /*
1649     * Child process for pictwpstops...  Redirect output of pictwpstops to a
1650     * file...
1651     */
1652
1653     close(1);
1654     dup(fd);
1655     close(fd);
1656
1657     if (!getuid())
1658     {
1659      /*
1660       * Change to an unpriviledged user...
1661       */
1662
1663       setgid(fileinfo.st_gid);
1664       setuid(fileinfo.st_uid);
1665     }
1666
1667     execlp("pictwpstops", printer, argv[1], argv[2], argv[3], argv[4], argv[5],
1668            filename, NULL);
1669     _cupsLangPrintf(stderr, _("ERROR: Unable to exec pictwpstops: %s\n"),
1670                     strerror(errno));
1671     return (errno);
1672   }
1673
1674   close(fd);
1675
1676   if (pid < 0)
1677   {
1678    /*
1679     * Error!
1680     */
1681
1682     _cupsLangPrintf(stderr, _("ERROR: Unable to fork pictwpstops: %s\n"),
1683                     strerror(errno));
1684     unlink(filename);
1685     if (ppdfile)
1686       unlink(ppdfile);
1687     return (-1);
1688   }
1689
1690  /*
1691   * Now wait for the filter to complete...
1692   */
1693
1694   if (wait(&status) < 0)
1695   {
1696     _cupsLangPrintf(stderr, _("ERROR: Unable to wait for pictwpstops: %s\n"),
1697                     strerror(errno));
1698     close(fd);
1699     unlink(filename);
1700     if (ppdfile)
1701       unlink(ppdfile);
1702     return (-1);
1703   }
1704
1705   if (ppdfile)
1706     unlink(ppdfile);
1707
1708   close(fd);
1709
1710   if (status)
1711   {
1712     if (status >= 256)
1713       _cupsLangPrintf(stderr, _("ERROR: pictwpstops exited with status %d!\n"),
1714                       status / 256);
1715     else
1716       _cupsLangPrintf(stderr, _("ERROR: pictwpstops exited on signal %d!\n"),
1717                       status);
1718
1719     unlink(filename);
1720     return (status);
1721   }
1722
1723  /*
1724   * Return with no errors..
1725   */
1726
1727   return (0);
1728 }
1729 #endif /* __APPLE__ */
1730
1731
1732 /*
1733  * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
1734  */
1735
1736 static void
1737 sigterm_handler(int sig)                /* I - Signal */
1738 {
1739   (void)sig;    /* remove compiler warnings... */
1740
1741   if (!job_cancelled)
1742   {
1743    /*
1744     * Flag that the job should be cancelled...
1745     */
1746
1747     job_cancelled = 1;
1748     return;
1749   }
1750
1751  /*
1752   * The scheduler already tried to cancel us once, now just terminate
1753   * after removing our temp files!
1754   */
1755
1756   if (tmpfilename[0])
1757     unlink(tmpfilename);
1758
1759 #ifdef __APPLE__
1760   if (pstmpname[0])
1761     unlink(pstmpname);
1762 #endif /* __APPLE__ */
1763
1764   exit(1);
1765 }
1766
1767
1768 /*
1769  * End of "$Id: ipp.c 7018 2007-10-10 22:14:03Z mike $".
1770  */