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