]> 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-r9198.
[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 int error = errno; /* Connection error */
476
477 if (job_canceled)
478 break;
479
480 if (getenv("CLASS") != NULL)
481 {
482 /*
483 * If the CLASS environment variable is set, the job was submitted
484 * to a class and not to a specific queue. In this case, we want
485 * to abort immediately so that the job can be requeued on the next
486 * available printer in the class.
487 */
488
489 _cupsLangPuts(stderr,
490 _("INFO: Unable to contact printer, queuing on next "
491 "printer in class...\n"));
492
493 /*
494 * Sleep 5 seconds to keep the job from requeuing too rapidly...
495 */
496
497 sleep(5);
498
499 return (CUPS_BACKEND_FAILED);
500 }
501
502 fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
503
504 if (errno == ECONNREFUSED || errno == EHOSTDOWN ||
505 errno == EHOSTUNREACH)
506 {
507 if (contimeout && (time(NULL) - start_time) > contimeout)
508 {
509 _cupsLangPuts(stderr, _("ERROR: The printer is not responding.\n"));
510 return (CUPS_BACKEND_FAILED);
511 }
512
513 switch (error)
514 {
515 case EHOSTDOWN :
516 _cupsLangPrintf(stderr,
517 _("WARNING: Network printer \'%s\' may not exist "
518 "or is unavailable at this time.\n"),
519 hostname);
520 break;
521
522 case EHOSTUNREACH :
523 _cupsLangPrintf(stderr,
524 _("WARNING: Network printer \'%s\' is "
525 "unreachable at this time.\n"),
526 hostname);
527 break;
528
529 case ECONNREFUSED :
530 default :
531 _cupsLangPrintf(stderr,
532 _("WARNING: Network printer \'%s\' is busy.\n"),
533 hostname);
534 break;
535 }
536
537 sleep(delay);
538
539 if (delay < 30)
540 delay += 5;
541 }
542 else if (h_errno)
543 {
544 _cupsLangPrintf(stderr,
545 _("ERROR: Unable to locate network printer \'%s\'.\n"),
546 hostname);
547 return (CUPS_BACKEND_STOP);
548 }
549 else
550 {
551 _cupsLangPrintf(stderr, _("ERROR: Network printer \'%s\' is not "
552 "responding.\n"), hostname);
553 sleep(30);
554 }
555
556 if (job_canceled)
557 break;
558 }
559 }
560 while (http == NULL);
561
562 if (job_canceled || !http)
563 return (CUPS_BACKEND_FAILED);
564
565 fputs("STATE: -connecting-to-device\n", stderr);
566 _cupsLangPuts(stderr, _("INFO: Connected to printer...\n"));
567
568 #ifdef AF_INET6
569 if (http->hostaddr->addr.sa_family == AF_INET6)
570 fprintf(stderr, "DEBUG: Connected to [%s]:%d (IPv6)...\n",
571 httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
572 ntohs(http->hostaddr->ipv6.sin6_port));
573 else
574 #endif /* AF_INET6 */
575 if (http->hostaddr->addr.sa_family == AF_INET)
576 fprintf(stderr, "DEBUG: Connected to %s:%d (IPv4)...\n",
577 httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
578 ntohs(http->hostaddr->ipv4.sin_port));
579
580 /*
581 * See if the printer supports SNMP...
582 */
583
584 if ((snmp_fd = _cupsSNMPOpen(http->hostaddr->addr.sa_family)) >= 0)
585 have_supplies = !backendSNMPSupplies(snmp_fd, http->hostaddr, &start_count,
586 NULL);
587 else
588 have_supplies = start_count = 0;
589
590 /*
591 * Build a URI for the printer and fill the standard IPP attributes for
592 * an IPP_PRINT_FILE request. We can't use the URI in argv[0] because it
593 * might contain username:password information...
594 */
595
596 httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri), scheme, NULL, hostname,
597 port, resource);
598
599 /*
600 * First validate the destination and see if the device supports multiple
601 * copies...
602 */
603
604 copies_sup = NULL;
605 cups_version = NULL;
606 format_sup = NULL;
607 media_col_sup = NULL;
608 supported = NULL;
609
610 do
611 {
612 /*
613 * Check for side-channel requests...
614 */
615
616 backendCheckSideChannel(snmp_fd, http->hostaddr);
617
618 /*
619 * Build the IPP request...
620 */
621
622 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
623 request->request.op.version[0] = version / 10;
624 request->request.op.version[1] = version % 10;
625
626 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
627 NULL, uri);
628
629 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
630 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
631 NULL, pattrs);
632
633 /*
634 * Do the request...
635 */
636
637 fputs("DEBUG: Getting supported attributes...\n", stderr);
638
639 if (http->version < HTTP_1_1)
640 {
641 fprintf(stderr, "DEBUG: Printer responded with HTTP version %d.%d.\n",
642 http->version / 100, http->version % 100);
643
644 _cupsLangPuts(stderr,
645 _("ERROR: Unable to print: the printer does not conform to "
646 "the IPP standard.\n"));
647 exit(CUPS_BACKEND_STOP);
648 }
649
650 if ((supported = cupsDoRequest(http, request, resource)) == NULL)
651 ipp_status = cupsLastError();
652 else
653 ipp_status = supported->request.status.status_code;
654
655 if (ipp_status > IPP_OK_CONFLICT)
656 {
657 if (ipp_status == IPP_PRINTER_BUSY ||
658 ipp_status == IPP_SERVICE_UNAVAILABLE)
659 {
660 if (contimeout && (time(NULL) - start_time) > contimeout)
661 {
662 _cupsLangPuts(stderr, _("ERROR: The printer is not responding.\n"));
663 return (CUPS_BACKEND_FAILED);
664 }
665
666 _cupsLangPrintf(stderr,
667 _("WARNING: Network host \'%s\' is busy; will retry in "
668 "%d seconds...\n"), hostname, delay);
669
670 report_printer_state(supported, 0);
671
672 sleep(delay);
673
674 if (delay < 30)
675 delay += 5;
676 }
677 else if ((ipp_status == IPP_BAD_REQUEST ||
678 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version > 10)
679 {
680 /*
681 * Switch to IPP/1.1 or IPP/1.0...
682 */
683
684 if (version >= 20)
685 {
686 _cupsLangPrintf(stderr,
687 _("INFO: Printer does not support IPP/%d.%d, trying "
688 "IPP/%s...\n"), version / 10, version % 10, "1.1");
689 version = 11;
690 }
691 else
692 {
693 _cupsLangPrintf(stderr,
694 _("INFO: Printer does not support IPP/%d.%d, trying "
695 "IPP/%s...\n"), version / 10, version % 10, "1.0");
696 version = 10;
697 }
698
699 httpReconnect(http);
700 }
701 else if (ipp_status == IPP_NOT_FOUND)
702 {
703 _cupsLangPuts(stderr, _("ERROR: The printer URI is incorrect or no longer exists.\n"));
704
705 if (supported)
706 ippDelete(supported);
707
708 return (CUPS_BACKEND_STOP);
709 }
710 else if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN)
711 {
712 if (!strncmp(httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE),
713 "Negotiate", 9))
714 auth_info_required = "negotiate";
715
716 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
717 return (CUPS_BACKEND_AUTH_REQUIRED);
718 }
719 else
720 {
721 _cupsLangPrintf(stderr,
722 _("ERROR: Unable to get printer status (%s)\n"),
723 cupsLastErrorString());
724 sleep(10);
725 }
726
727 if (supported)
728 ippDelete(supported);
729
730 continue;
731 }
732
733 /*
734 * Check for supported attributes...
735 */
736
737 if ((copies_sup = ippFindAttribute(supported, "copies-supported",
738 IPP_TAG_RANGE)) != NULL)
739 {
740 /*
741 * Has the "copies-supported" attribute - does it have an upper
742 * bound > 1?
743 */
744
745 fprintf(stderr, "DEBUG: copies-supported=%d-%d\n",
746 copies_sup->values[0].range.lower,
747 copies_sup->values[0].range.upper);
748
749 if (copies_sup->values[0].range.upper <= 1)
750 copies_sup = NULL; /* No */
751 }
752
753 cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT);
754
755 if ((format_sup = ippFindAttribute(supported, "document-format-supported",
756 IPP_TAG_MIMETYPE)) != NULL)
757 {
758 fprintf(stderr, "DEBUG: document-format-supported (%d values)\n",
759 format_sup->num_values);
760 for (i = 0; i < format_sup->num_values; i ++)
761 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
762 format_sup->values[i].string.text);
763 }
764
765 if ((media_col_sup = ippFindAttribute(supported, "media-col-supported",
766 IPP_TAG_KEYWORD)) != NULL)
767 {
768 fprintf(stderr, "DEBUG: media-col-supported (%d values)\n",
769 media_col_sup->num_values);
770 for (i = 0; i < media_col_sup->num_values; i ++)
771 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
772 media_col_sup->values[i].string.text);
773 }
774
775 report_printer_state(supported, 0);
776 }
777 while (ipp_status > IPP_OK_CONFLICT);
778
779 /*
780 * See if the printer is accepting jobs and is not stopped; if either
781 * condition is true and we are printing to a class, requeue the job...
782 */
783
784 if (getenv("CLASS") != NULL)
785 {
786 printer_state = ippFindAttribute(supported, "printer-state",
787 IPP_TAG_ENUM);
788 printer_accepting = ippFindAttribute(supported, "printer-is-accepting-jobs",
789 IPP_TAG_BOOLEAN);
790
791 if (printer_state == NULL ||
792 (printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
793 waitprinter) ||
794 printer_accepting == NULL ||
795 !printer_accepting->values[0].boolean)
796 {
797 /*
798 * If the CLASS environment variable is set, the job was submitted
799 * to a class and not to a specific queue. In this case, we want
800 * to abort immediately so that the job can be requeued on the next
801 * available printer in the class.
802 */
803
804 _cupsLangPuts(stderr,
805 _("INFO: Unable to contact printer, queuing on next "
806 "printer in class...\n"));
807
808 ippDelete(supported);
809 httpClose(http);
810
811 /*
812 * Sleep 5 seconds to keep the job from requeuing too rapidly...
813 */
814
815 sleep(5);
816
817 return (CUPS_BACKEND_FAILED);
818 }
819 }
820
821 /*
822 * See if the printer supports multiple copies...
823 */
824
825 copies = atoi(argv[4]);
826
827 if (copies_sup || argc < 7)
828 {
829 copies_remaining = 1;
830
831 if (argc < 7)
832 copies = 1;
833 }
834 else
835 copies_remaining = copies;
836
837 /*
838 * Then issue the print-job request...
839 */
840
841 job_id = 0;
842
843 while (copies_remaining > 0)
844 {
845 /*
846 * Check for side-channel requests...
847 */
848
849 backendCheckSideChannel(snmp_fd, http->hostaddr);
850
851 /*
852 * Build the IPP request...
853 */
854
855 if (job_canceled)
856 break;
857
858 if (num_files > 1)
859 request = ippNewRequest(IPP_CREATE_JOB);
860 else
861 request = ippNewRequest(IPP_PRINT_JOB);
862
863 request->request.op.version[0] = version / 10;
864 request->request.op.version[1] = version % 10;
865
866 fprintf(stderr, "DEBUG: %s IPP/%d.%d\n",
867 ippOpString(request->request.op.operation_id),
868 request->request.op.version[0],
869 request->request.op.version[1]);
870
871 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
872 NULL, uri);
873 fprintf(stderr, "DEBUG: printer-uri=\"%s\"\n", uri);
874
875 if (argv[2][0])
876 {
877 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
878 "requesting-user-name", NULL, argv[2]);
879 fprintf(stderr, "DEBUG: requesting-user-name=\"%s\"\n", argv[2]);
880 }
881
882 if (argv[3][0])
883 {
884 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
885 argv[3]);
886 fprintf(stderr, "DEBUG: job-name=\"%s\"\n", argv[3]);
887 }
888
889 #ifdef HAVE_LIBZ
890 if (compression)
891 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
892 "compression", NULL, "gzip");
893 #endif /* HAVE_LIBZ */
894
895 /*
896 * Handle options on the command-line...
897 */
898
899 options = NULL;
900 num_options = cupsParseOptions(argv[5], 0, &options);
901
902 if (format_sup != NULL)
903 {
904 for (i = 0; i < format_sup->num_values; i ++)
905 if (!strcasecmp(final_content_type, format_sup->values[i].string.text))
906 break;
907
908 if (i < format_sup->num_values)
909 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
910 "document-format", NULL, final_content_type);
911 }
912
913 if (send_options)
914 {
915 if (cups_version || !media_col_sup)
916 {
917 /*
918 * When talking to another CUPS server, send all options...
919 */
920
921 cupsEncodeOptions(request, num_options, options);
922 }
923 else
924 {
925 /*
926 * Otherwise send standard IPP attributes...
927 */
928
929 char cachefile[1024];/* Printer PWG cache file */
930 const char *cups_cachedir; /* Location of cache file */
931 _pwg_t *pwg; /* PWG mapping data */
932 const char *keyword; /* PWG keyword */
933 _pwg_size_t *size; /* PWG media size */
934
935
936 if ((cups_cachedir = getenv("CUPS_CACHEDIR")) == NULL)
937 cups_cachedir = CUPS_CACHEDIR;
938
939 snprintf(cachefile, sizeof(cachefile), "%s/%s.pwg", cups_cachedir,
940 getenv("PRINTER"));
941
942 if ((keyword = cupsGetOption("PageSize", num_options, options)) == NULL)
943 keyword = cupsGetOption("media", num_options, options);
944
945 pwg = _pwgCreateWithFile(cachefile);
946 size = _pwgGetSize(pwg, keyword);
947
948 if (media_col_sup && size)
949 {
950 ipp_t *media_col, /* media-col value */
951 *media_size; /* media-size value */
952 const char *media_source, /* media-source value */
953 *media_type; /* media-type value */
954
955 media_size = ippNew();
956 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
957 "x-dimension", size->width);
958 ippAddInteger(media_size, IPP_TAG_ZERO, IPP_TAG_INTEGER,
959 "y-dimension", size->length);
960
961 media_col = ippNew();
962 ippAddCollection(media_col, IPP_TAG_ZERO, "media-size", media_size);
963
964 media_source = _pwgGetSource(pwg, cupsGetOption("InputSlot",
965 num_options,
966 options));
967 media_type = _pwgGetType(pwg, cupsGetOption("MediaType",
968 num_options, options));
969
970 for (i = 0; i < media_col_sup->num_values; i ++)
971 {
972 if (!strcmp(media_col_sup->values[i].string.text,
973 "media-left-margin"))
974 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
975 "media-left-margin", size->left);
976 else if (!strcmp(media_col_sup->values[i].string.text,
977 "media-bottom-margin"))
978 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
979 "media-bottom-margin", size->left);
980 else if (!strcmp(media_col_sup->values[i].string.text,
981 "media-right-margin"))
982 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
983 "media-right-margin", size->left);
984 else if (!strcmp(media_col_sup->values[i].string.text,
985 "media-top-margin"))
986 ippAddInteger(media_col, IPP_TAG_ZERO, IPP_TAG_INTEGER,
987 "media-top-margin", size->left);
988 else if (!strcmp(media_col_sup->values[i].string.text,
989 "media-source") && media_source)
990 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
991 "media-source", NULL, media_source);
992 else if (!strcmp(media_col_sup->values[i].string.text,
993 "media-type") && media_type)
994 ippAddString(media_col, IPP_TAG_ZERO, IPP_TAG_KEYWORD,
995 "media-type", NULL, media_type);
996 }
997
998 ippAddCollection(request, IPP_TAG_JOB, "media-col", media_col);
999 }
1000 else if (size)
1001 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media",
1002 NULL, size->map.pwg);
1003 else if (keyword)
1004 {
1005 _pwg_media_t *found; /* PWG media */
1006
1007
1008 if ((found = _pwgMediaForPPD(keyword)) == NULL)
1009 keyword = found->pwg;
1010 else if ((found = _pwgMediaForLegacy(keyword)) == NULL)
1011 keyword = found->pwg;
1012
1013 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "media",
1014 NULL, keyword);
1015 }
1016
1017 if ((keyword = cupsGetOption("output-bin", num_options,
1018 options)) == NULL)
1019 keyword = _pwgGetBin(pwg, cupsGetOption("OutputBin", num_options,
1020 options));
1021
1022 if (keyword)
1023 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "output-bin",
1024 NULL, keyword);
1025
1026 if ((keyword = cupsGetOption("output-mode", num_options,
1027 options)) != NULL)
1028 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "output-mode",
1029 NULL, keyword);
1030
1031 if ((keyword = cupsGetOption("sides", num_options, options)) != NULL)
1032 ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, "sides",
1033 NULL, keyword);
1034
1035 _pwgDestroy(pwg);
1036 }
1037
1038 if (copies_sup && copies > 1)
1039 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", copies);
1040 }
1041
1042 cupsFreeOptions(num_options, options);
1043
1044 /*
1045 * Do the request...
1046 */
1047
1048 if (num_files > 1)
1049 response = cupsDoRequest(http, request, resource);
1050 else
1051 {
1052 fputs("DEBUG: Sending file using chunking...\n", stderr);
1053 http_status = cupsSendRequest(http, request, resource, 0);
1054 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1055 {
1056 if (num_files == 1)
1057 fd = open(files[0], O_RDONLY);
1058 else
1059 fd = 0;
1060
1061 while ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1062 {
1063 fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
1064
1065 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1066 != HTTP_CONTINUE)
1067 break;
1068 else
1069 {
1070 /*
1071 * Check for side-channel requests...
1072 */
1073
1074 backendCheckSideChannel(snmp_fd, http->hostaddr);
1075 }
1076 }
1077
1078 if (num_files == 1)
1079 close(fd);
1080 }
1081
1082 response = cupsGetResponse(http, resource);
1083 ippDelete(request);
1084 }
1085
1086 ipp_status = cupsLastError();
1087
1088 if (ipp_status > IPP_OK_CONFLICT)
1089 {
1090 job_id = 0;
1091
1092 if (job_canceled)
1093 break;
1094
1095 if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
1096 ipp_status == IPP_PRINTER_BUSY)
1097 {
1098 _cupsLangPuts(stderr,
1099 _("INFO: Printer busy; will retry in 10 seconds...\n"));
1100 sleep(10);
1101 }
1102 else
1103 {
1104 /*
1105 * Update auth-info-required as needed...
1106 */
1107
1108 _cupsLangPrintf(stderr, _("ERROR: Print file was not accepted (%s)\n"),
1109 cupsLastErrorString());
1110
1111 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN)
1112 {
1113 fprintf(stderr, "DEBUG: WWW-Authenticate=\"%s\"\n",
1114 httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE));
1115
1116 /*
1117 * Normal authentication goes through the password callback, which sets
1118 * auth_info_required to "username,password". Kerberos goes directly
1119 * through GSSAPI, so look for Negotiate in the WWW-Authenticate header
1120 * here and set auth_info_required as needed...
1121 */
1122
1123 if (!strncmp(httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE),
1124 "Negotiate", 9))
1125 auth_info_required = "negotiate";
1126 }
1127 }
1128 }
1129 else if ((job_id_attr = ippFindAttribute(response, "job-id",
1130 IPP_TAG_INTEGER)) == NULL)
1131 {
1132 _cupsLangPuts(stderr,
1133 _("NOTICE: Print file accepted - job ID unknown.\n"));
1134 job_id = 0;
1135 }
1136 else
1137 {
1138 job_id = job_id_attr->values[0].integer;
1139 _cupsLangPrintf(stderr, _("NOTICE: Print file accepted - job ID %d.\n"),
1140 job_id);
1141 }
1142
1143 ippDelete(response);
1144
1145 if (job_canceled)
1146 break;
1147
1148 if (job_id && num_files > 1)
1149 {
1150 for (i = 0; i < num_files; i ++)
1151 {
1152 /*
1153 * Check for side-channel requests...
1154 */
1155
1156 backendCheckSideChannel(snmp_fd, http->hostaddr);
1157
1158 /*
1159 * Send the next file in the job...
1160 */
1161
1162 request = ippNewRequest(IPP_SEND_DOCUMENT);
1163 request->request.op.version[0] = version / 10;
1164 request->request.op.version[1] = version % 10;
1165
1166 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1167 NULL, uri);
1168
1169 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1170 job_id);
1171
1172 if (argv[2][0])
1173 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1174 "requesting-user-name", NULL, argv[2]);
1175
1176 if ((i + 1) == num_files)
1177 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
1178
1179 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1180 "document-format", NULL, content_type);
1181
1182 fprintf(stderr, "DEBUG: Sending file %d using chunking...\n", i + 1);
1183 http_status = cupsSendRequest(http, request, resource, 0);
1184 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA &&
1185 (fd = open(files[i], O_RDONLY)) >= 0)
1186 {
1187 while ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1188 {
1189 if ((http_status = cupsWriteRequestData(http, buffer, bytes))
1190 != HTTP_CONTINUE)
1191 break;
1192 else
1193 {
1194 /*
1195 * Check for side-channel requests...
1196 */
1197
1198 backendCheckSideChannel(snmp_fd, http->hostaddr);
1199 }
1200 }
1201
1202 close(fd);
1203 }
1204
1205 ippDelete(cupsGetResponse(http, resource));
1206 ippDelete(request);
1207
1208 if (cupsLastError() > IPP_OK_CONFLICT)
1209 {
1210 ipp_status = cupsLastError();
1211
1212 _cupsLangPrintf(stderr,
1213 _("ERROR: Unable to add file %d to job: %s\n"),
1214 job_id, cupsLastErrorString());
1215 break;
1216 }
1217 }
1218 }
1219
1220 if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
1221 {
1222 fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
1223 copies_remaining --;
1224 }
1225 else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
1226 ipp_status == IPP_PRINTER_BUSY)
1227 continue;
1228 else
1229 copies_remaining --;
1230
1231 /*
1232 * Wait for the job to complete...
1233 */
1234
1235 if (!job_id || !waitjob)
1236 continue;
1237
1238 _cupsLangPuts(stderr, _("INFO: Waiting for job to complete...\n"));
1239
1240 for (delay = 1; !job_canceled;)
1241 {
1242 /*
1243 * Check for side-channel requests...
1244 */
1245
1246 backendCheckSideChannel(snmp_fd, http->hostaddr);
1247
1248 /*
1249 * Build an IPP_GET_JOB_ATTRIBUTES request...
1250 */
1251
1252 request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
1253 request->request.op.version[0] = version / 10;
1254 request->request.op.version[1] = version % 10;
1255
1256 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1257 NULL, uri);
1258
1259 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1260 job_id);
1261
1262 if (argv[2][0])
1263 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1264 "requesting-user-name", NULL, argv[2]);
1265
1266 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1267 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
1268 NULL, jattrs);
1269
1270 /*
1271 * Do the request...
1272 */
1273
1274 response = cupsDoRequest(http, request, resource);
1275 ipp_status = cupsLastError();
1276
1277 if (ipp_status == IPP_NOT_FOUND)
1278 {
1279 /*
1280 * Job has gone away and/or the server has no job history...
1281 */
1282
1283 ippDelete(response);
1284
1285 ipp_status = IPP_OK;
1286 break;
1287 }
1288
1289 if (ipp_status > IPP_OK_CONFLICT)
1290 {
1291 if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
1292 ipp_status != IPP_PRINTER_BUSY)
1293 {
1294 ippDelete(response);
1295
1296 _cupsLangPrintf(stderr,
1297 _("ERROR: Unable to get job %d attributes (%s)\n"),
1298 job_id, cupsLastErrorString());
1299 break;
1300 }
1301 }
1302
1303 if (response)
1304 {
1305 if ((job_state = ippFindAttribute(response, "job-state",
1306 IPP_TAG_ENUM)) != NULL)
1307 {
1308 /*
1309 * Stop polling if the job is finished or pending-held...
1310 */
1311
1312 if (job_state->values[0].integer > IPP_JOB_STOPPED)
1313 {
1314 if ((job_sheets = ippFindAttribute(response,
1315 "job-media-sheets-completed",
1316 IPP_TAG_INTEGER)) != NULL)
1317 fprintf(stderr, "PAGE: total %d\n",
1318 job_sheets->values[0].integer);
1319
1320 ippDelete(response);
1321 break;
1322 }
1323 }
1324 else
1325 {
1326 /*
1327 * If the printer does not return a job-state attribute, it does not
1328 * conform to the IPP specification - break out immediately and fail
1329 * the job...
1330 */
1331
1332 fputs("DEBUG: No job-state available from printer - stopping queue.\n",
1333 stderr);
1334 ipp_status = IPP_INTERNAL_ERROR;
1335 break;
1336 }
1337 }
1338
1339 ippDelete(response);
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 * Wait 1-10 seconds before polling again...
1349 */
1350
1351 sleep(delay);
1352
1353 delay ++;
1354 if (delay > 10)
1355 delay = 1;
1356 }
1357 }
1358
1359 /*
1360 * Cancel the job as needed...
1361 */
1362
1363 if (job_canceled && job_id)
1364 cancel_job(http, uri, job_id, resource, argv[2], version);
1365
1366 /*
1367 * Check the printer state and report it if necessary...
1368 */
1369
1370 check_printer_state(http, uri, resource, argv[2], version, job_id);
1371
1372 /*
1373 * Collect the final page count as needed...
1374 */
1375
1376 if (have_supplies &&
1377 !backendSNMPSupplies(snmp_fd, http->hostaddr, &page_count, NULL) &&
1378 page_count > start_count)
1379 fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
1380
1381 #ifdef HAVE_GSSAPI
1382 /*
1383 * See if we used Kerberos at all...
1384 */
1385
1386 if (http->gssctx)
1387 auth_info_required = "negotiate";
1388 #endif /* HAVE_GSSAPI */
1389
1390 /*
1391 * Free memory...
1392 */
1393
1394 httpClose(http);
1395
1396 ippDelete(supported);
1397
1398 /*
1399 * Remove the temporary file(s) if necessary...
1400 */
1401
1402 #ifdef HAVE_LIBZ
1403 if (compression)
1404 {
1405 for (i = 0; i < num_files; i ++)
1406 unlink(files[i]);
1407 }
1408 #endif /* HAVE_LIBZ */
1409
1410 /*
1411 * Return the queue status...
1412 */
1413
1414 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
1415
1416 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN)
1417 return (CUPS_BACKEND_AUTH_REQUIRED);
1418 else if (ipp_status == IPP_INTERNAL_ERROR)
1419 return (CUPS_BACKEND_STOP);
1420 else if (ipp_status > IPP_OK_CONFLICT)
1421 return (CUPS_BACKEND_FAILED);
1422 else
1423 {
1424 _cupsLangPuts(stderr, _("INFO: Ready to print.\n"));
1425 return (CUPS_BACKEND_OK);
1426 }
1427 }
1428
1429
1430 /*
1431 * 'cancel_job()' - Cancel a print job.
1432 */
1433
1434 static void
1435 cancel_job(http_t *http, /* I - HTTP connection */
1436 const char *uri, /* I - printer-uri */
1437 int id, /* I - job-id */
1438 const char *resource, /* I - Resource path */
1439 const char *user, /* I - requesting-user-name */
1440 int version) /* I - IPP version */
1441 {
1442 ipp_t *request; /* Cancel-Job request */
1443
1444
1445 _cupsLangPuts(stderr, _("INFO: Canceling print job...\n"));
1446
1447 request = ippNewRequest(IPP_CANCEL_JOB);
1448 request->request.op.version[0] = version / 10;
1449 request->request.op.version[1] = version % 10;
1450
1451 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1452 NULL, uri);
1453 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id);
1454
1455 if (user && user[0])
1456 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1457 "requesting-user-name", NULL, user);
1458
1459 /*
1460 * Do the request...
1461 */
1462
1463 ippDelete(cupsDoRequest(http, request, resource));
1464
1465 if (cupsLastError() > IPP_OK_CONFLICT)
1466 _cupsLangPrintf(stderr, _("ERROR: Unable to cancel job %d: %s\n"), id,
1467 cupsLastErrorString());
1468 }
1469
1470
1471 /*
1472 * 'check_printer_state()' - Check the printer state...
1473 */
1474
1475 static void
1476 check_printer_state(
1477 http_t *http, /* I - HTTP connection */
1478 const char *uri, /* I - Printer URI */
1479 const char *resource, /* I - Resource path */
1480 const char *user, /* I - Username, if any */
1481 int version, /* I - IPP version */
1482 int job_id) /* I - Current job ID */
1483 {
1484 ipp_t *request, /* IPP request */
1485 *response; /* IPP response */
1486 static const char * const attrs[] = /* Attributes we want */
1487 {
1488 "marker-colors",
1489 "marker-levels",
1490 "marker-message",
1491 "marker-names",
1492 "marker-types",
1493 "printer-state-message",
1494 "printer-state-reasons"
1495 };
1496
1497
1498 /*
1499 * Check on the printer state...
1500 */
1501
1502 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
1503 request->request.op.version[0] = version / 10;
1504 request->request.op.version[1] = version % 10;
1505
1506 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1507 NULL, uri);
1508
1509 if (user && user[0])
1510 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1511 "requesting-user-name", NULL, user);
1512
1513 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1514 "requested-attributes",
1515 (int)(sizeof(attrs) / sizeof(attrs[0])), NULL, attrs);
1516
1517 /*
1518 * Do the request...
1519 */
1520
1521 if ((response = cupsDoRequest(http, request, resource)) != NULL)
1522 {
1523 report_printer_state(response, job_id);
1524 ippDelete(response);
1525 }
1526 }
1527
1528
1529 #ifdef HAVE_LIBZ
1530 /*
1531 * 'compress_files()' - Compress print files...
1532 */
1533
1534 static void
1535 compress_files(int num_files, /* I - Number of files */
1536 char **files) /* I - Files */
1537 {
1538 int i, /* Looping var */
1539 fd; /* Temporary file descriptor */
1540 ssize_t bytes; /* Bytes read/written */
1541 size_t total; /* Total bytes read */
1542 cups_file_t *in, /* Input file */
1543 *out; /* Output file */
1544 struct stat outinfo; /* Output file information */
1545 char filename[1024], /* Temporary filename */
1546 buffer[32768]; /* Copy buffer */
1547
1548
1549 fprintf(stderr, "DEBUG: Compressing %d job files...\n", num_files);
1550 for (i = 0; i < num_files; i ++)
1551 {
1552 if ((fd = cupsTempFd(filename, sizeof(filename))) < 0)
1553 {
1554 _cupsLangPrintf(stderr,
1555 _("ERROR: Unable to create temporary compressed print "
1556 "file: %s\n"), strerror(errno));
1557 exit(CUPS_BACKEND_FAILED);
1558 }
1559
1560 if ((out = cupsFileOpenFd(fd, "w9")) == NULL)
1561 {
1562 _cupsLangPrintf(stderr,
1563 _("ERROR: Unable to open temporary compressed print "
1564 "file: %s\n"), strerror(errno));
1565 exit(CUPS_BACKEND_FAILED);
1566 }
1567
1568 if ((in = cupsFileOpen(files[i], "r")) == NULL)
1569 {
1570 _cupsLangPrintf(stderr,
1571 _("ERROR: Unable to open print file \"%s\": %s\n"),
1572 files[i], strerror(errno));
1573 cupsFileClose(out);
1574 exit(CUPS_BACKEND_FAILED);
1575 }
1576
1577 total = 0;
1578 while ((bytes = cupsFileRead(in, buffer, sizeof(buffer))) > 0)
1579 if (cupsFileWrite(out, buffer, bytes) < bytes)
1580 {
1581 _cupsLangPrintf(stderr,
1582 _("ERROR: Unable to write %d bytes to \"%s\": %s\n"),
1583 (int)bytes, filename, strerror(errno));
1584 cupsFileClose(in);
1585 cupsFileClose(out);
1586 exit(CUPS_BACKEND_FAILED);
1587 }
1588 else
1589 total += bytes;
1590
1591 cupsFileClose(out);
1592 cupsFileClose(in);
1593
1594 files[i] = strdup(filename);
1595
1596 if (!stat(filename, &outinfo))
1597 fprintf(stderr,
1598 "DEBUG: File %d compressed to %.1f%% of original size, "
1599 CUPS_LLFMT " bytes...\n",
1600 i + 1, 100.0 * outinfo.st_size / total,
1601 CUPS_LLCAST outinfo.st_size);
1602 }
1603 }
1604 #endif /* HAVE_LIBZ */
1605
1606
1607 /*
1608 * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
1609 */
1610
1611 static const char * /* O - Password */
1612 password_cb(const char *prompt) /* I - Prompt (not used) */
1613 {
1614 (void)prompt;
1615
1616 /*
1617 * Remember that we need to authenticate...
1618 */
1619
1620 auth_info_required = "username,password";
1621
1622 if (password && *password && password_tries < 3)
1623 {
1624 password_tries ++;
1625
1626 return (password);
1627 }
1628 else
1629 {
1630 /*
1631 * Give up after 3 tries or if we don't have a password to begin with...
1632 */
1633
1634 return (NULL);
1635 }
1636 }
1637
1638
1639 /*
1640 * 'report_attr()' - Report an IPP attribute value.
1641 */
1642
1643 static void
1644 report_attr(ipp_attribute_t *attr) /* I - Attribute */
1645 {
1646 int i; /* Looping var */
1647 char value[1024], /* Value string */
1648 *valptr, /* Pointer into value string */
1649 *attrptr; /* Pointer into attribute value */
1650
1651
1652 /*
1653 * Convert the attribute values into quoted strings...
1654 */
1655
1656 for (i = 0, valptr = value;
1657 i < attr->num_values && valptr < (value + sizeof(value) - 10);
1658 i ++)
1659 {
1660 if (i > 0)
1661 *valptr++ = ',';
1662
1663 switch (attr->value_tag)
1664 {
1665 case IPP_TAG_INTEGER :
1666 case IPP_TAG_ENUM :
1667 snprintf(valptr, sizeof(value) - (valptr - value), "%d",
1668 attr->values[i].integer);
1669 valptr += strlen(valptr);
1670 break;
1671
1672 case IPP_TAG_TEXT :
1673 case IPP_TAG_NAME :
1674 case IPP_TAG_KEYWORD :
1675 *valptr++ = '\"';
1676 for (attrptr = attr->values[i].string.text;
1677 *attrptr && valptr < (value + sizeof(value) - 10);
1678 attrptr ++)
1679 {
1680 if (*attrptr == '\\' || *attrptr == '\"')
1681 *valptr++ = '\\';
1682
1683 *valptr++ = *attrptr;
1684 }
1685 *valptr++ = '\"';
1686 break;
1687
1688 default :
1689 /*
1690 * Unsupported value type...
1691 */
1692
1693 return;
1694 }
1695 }
1696
1697 *valptr = '\0';
1698
1699 /*
1700 * Tell the scheduler about the new values...
1701 */
1702
1703 fprintf(stderr, "ATTR: %s=%s\n", attr->name, value);
1704 }
1705
1706
1707 /*
1708 * 'report_printer_state()' - Report the printer state.
1709 */
1710
1711 static int /* O - Number of reasons shown */
1712 report_printer_state(ipp_t *ipp, /* I - IPP response */
1713 int job_id) /* I - Current job ID */
1714 {
1715 int i; /* Looping var */
1716 int count; /* Count of reasons shown... */
1717 ipp_attribute_t *psm, /* printer-state-message */
1718 *reasons, /* printer-state-reasons */
1719 *marker; /* marker-* attributes */
1720 const char *reason; /* Current reason */
1721 const char *prefix; /* Prefix for STATE: line */
1722 char state[1024]; /* State string */
1723
1724
1725 if ((psm = ippFindAttribute(ipp, "printer-state-message",
1726 IPP_TAG_TEXT)) != NULL)
1727 fprintf(stderr, "INFO: %s\n", psm->values[0].string.text);
1728
1729 if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
1730 IPP_TAG_KEYWORD)) == NULL)
1731 return (0);
1732
1733 state[0] = '\0';
1734 prefix = "STATE: ";
1735
1736 for (i = 0, count = 0; i < reasons->num_values; i ++)
1737 {
1738 reason = reasons->values[i].string.text;
1739
1740 if (strcmp(reason, "paused") &&
1741 strcmp(reason, "com.apple.print.recoverable-warning"))
1742 {
1743 strlcat(state, prefix, sizeof(state));
1744 strlcat(state, reason, sizeof(state));
1745
1746 prefix = ",";
1747 }
1748 }
1749
1750 if (state[0])
1751 fprintf(stderr, "%s\n", state);
1752
1753 /*
1754 * Relay the current marker-* attribute values...
1755 */
1756
1757 if ((marker = ippFindAttribute(ipp, "marker-colors", IPP_TAG_NAME)) != NULL)
1758 report_attr(marker);
1759 if ((marker = ippFindAttribute(ipp, "marker-high-levels",
1760 IPP_TAG_INTEGER)) != NULL)
1761 report_attr(marker);
1762 if ((marker = ippFindAttribute(ipp, "marker-levels",
1763 IPP_TAG_INTEGER)) != NULL)
1764 report_attr(marker);
1765 if ((marker = ippFindAttribute(ipp, "marker-low-levels",
1766 IPP_TAG_INTEGER)) != NULL)
1767 report_attr(marker);
1768 if ((marker = ippFindAttribute(ipp, "marker-message", IPP_TAG_TEXT)) != NULL)
1769 report_attr(marker);
1770 if ((marker = ippFindAttribute(ipp, "marker-names", IPP_TAG_NAME)) != NULL)
1771 report_attr(marker);
1772 if ((marker = ippFindAttribute(ipp, "marker-types", IPP_TAG_KEYWORD)) != NULL)
1773 report_attr(marker);
1774
1775 return (count);
1776 }
1777
1778
1779 /*
1780 * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
1781 */
1782
1783 static void
1784 sigterm_handler(int sig) /* I - Signal */
1785 {
1786 (void)sig; /* remove compiler warnings... */
1787
1788 if (!job_canceled)
1789 {
1790 /*
1791 * Flag that the job should be cancelled...
1792 */
1793
1794 job_canceled = 1;
1795 return;
1796 }
1797
1798 exit(1);
1799 }
1800
1801
1802 /*
1803 * End of "$Id: ipp.c 7948 2008-09-17 00:04:12Z mike $".
1804 */
Unnamed repository; edit this file 'description' to name the repository.