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