]> 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
License change: Apache License, Version 2.0.
[thirdparty/cups.git] / backend / ipp.c
1 /*
2 * IPP backend for CUPS.
3 *
4 * Copyright 2007-2017 by Apple Inc.
5 * Copyright 1997-2007 by Easy Software Products, all rights reserved.
6 *
7 * These coded instructions, statements, and computer programs are the
8 * property of Apple Inc. and are protected by Federal copyright
9 * law. Distribution and use rights are outlined in the file "LICENSE.txt"
10 * "LICENSE" which should have been included with this file. If this
11 * file is missing or damaged, see the license at "http://www.cups.org/".
12 */
13
14 /*
15 * Include necessary headers.
16 */
17
18 #include "backend-private.h"
19 #include <cups/ppd-private.h>
20 #include <cups/array-private.h>
21 #include <sys/types.h>
22 #include <sys/stat.h>
23 #include <sys/wait.h>
24 #if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
25 # include <xpc/xpc.h>
26 # define kPMPrintUIToolAgent "com.apple.printuitool.agent"
27 # define kPMStartJob 100
28 # define kPMWaitForJob 101
29 # ifdef HAVE_XPC_PRIVATE_H
30 # include <xpc/private.h>
31 # else
32 extern void xpc_connection_set_target_uid(xpc_connection_t connection,
33 uid_t uid);
34 # endif /* HAVE_XPC_PRIVATE_H */
35 #endif /* HAVE_GSSAPI && HAVE_XPC */
36
37
38 /*
39 * Bits for job-state-reasons we care about...
40 */
41
42 #define _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED 0x01
43 #define _CUPS_JSR_ACCOUNT_CLOSED 0x02
44 #define _CUPS_JSR_ACCOUNT_INFO_NEEDED 0x04
45 #define _CUPS_JSR_ACCOUNT_LIMIT_REACHED 0x08
46 #define _CUPS_JSR_JOB_PASSWORD_WAIT 0x10
47 #define _CUPS_JSR_JOB_RELEASE_WAIT 0x20
48
49
50 /*
51 * Types...
52 */
53
54 typedef struct _cups_monitor_s /**** Monitoring data ****/
55 {
56 const char *uri, /* Printer URI */
57 *hostname, /* Hostname */
58 *user, /* Username */
59 *resource; /* Resource path */
60 int port, /* Port number */
61 version, /* IPP version */
62 job_id, /* Job ID for submitted job */
63 job_reasons, /* Job state reasons bits */
64 create_job, /* Support Create-Job? */
65 get_job_attrs; /* Support Get-Job-Attributes? */
66 const char *job_name; /* Job name for submitted job */
67 http_encryption_t encryption; /* Use encryption? */
68 ipp_jstate_t job_state; /* Current job state */
69 ipp_pstate_t printer_state; /* Current printer state */
70 } _cups_monitor_t;
71
72
73 /*
74 * Globals...
75 */
76
77 static const char *auth_info_required;
78 /* New auth-info-required value */
79 #if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
80 static pid_t child_pid = 0; /* Child process ID */
81 #endif /* HAVE_GSSAPI && HAVE_XPC */
82 static const char * const jattrs[] = /* Job attributes we want */
83 {
84 "job-id",
85 "job-impressions-completed",
86 "job-media-sheets-completed",
87 "job-name",
88 "job-originating-user-name",
89 "job-state",
90 "job-state-reasons"
91 };
92 static int job_canceled = 0,
93 /* Job cancelled? */
94 uri_credentials = 0;
95 /* Credentials supplied in URI? */
96 static char username[256] = "",
97 /* Username for device URI */
98 *password = NULL;
99 /* Password for device URI */
100 static const char * const pattrs[] = /* Printer attributes we want */
101 {
102 #ifdef HAVE_LIBZ
103 "compression-supported",
104 #endif /* HAVE_LIBZ */
105 "copies-supported",
106 "cups-version",
107 "document-format-supported",
108 "job-password-encryption-supported",
109 "marker-colors",
110 "marker-high-levels",
111 "marker-levels",
112 "marker-low-levels",
113 "marker-message",
114 "marker-names",
115 "marker-types",
116 "media-col-supported",
117 "multiple-document-handling-supported",
118 "operations-supported",
119 "print-color-mode-supported",
120 "printer-alert",
121 "printer-alert-description",
122 "printer-is-accepting-jobs",
123 "printer-mandatory-job-attributes",
124 "printer-state",
125 "printer-state-message",
126 "printer-state-reasons"
127 };
128 static const char * const remote_job_states[] =
129 { /* Remote job state keywords */
130 "+cups-remote-pending",
131 "+cups-remote-pending-held",
132 "+cups-remote-processing",
133 "+cups-remote-stopped",
134 "+cups-remote-canceled",
135 "+cups-remote-aborted",
136 "+cups-remote-completed"
137 };
138 static _cups_mutex_t report_mutex = _CUPS_MUTEX_INITIALIZER;
139 /* Mutex to control access */
140 static int num_attr_cache = 0;
141 /* Number of cached attributes */
142 static cups_option_t *attr_cache = NULL;
143 /* Cached attributes */
144 static cups_array_t *state_reasons; /* Array of printe-state-reasons keywords */
145 static char tmpfilename[1024] = "";
146 /* Temporary spool file name */
147 static char mandatory_attrs[1024] = "";
148 /* cupsMandatory value */
149
150
151 /*
152 * Local functions...
153 */
154
155 static void cancel_job(http_t *http, const char *uri, int id,
156 const char *resource, const char *user,
157 int version);
158 static ipp_pstate_t check_printer_state(http_t *http, const char *uri,
159 const char *resource,
160 const char *user, int version);
161 static void debug_attributes(ipp_t *ipp);
162 static void *monitor_printer(_cups_monitor_t *monitor);
163 static ipp_t *new_request(ipp_op_t op, int version, const char *uri,
164 const char *user, const char *title,
165 int num_options, cups_option_t *options,
166 const char *compression, int copies,
167 const char *format, _ppd_cache_t *pc,
168 ppd_file_t *ppd,
169 ipp_attribute_t *media_col_sup,
170 ipp_attribute_t *doc_handling_sup,
171 ipp_attribute_t *print_color_mode_sup);
172 static const char *password_cb(const char *prompt, http_t *http,
173 const char *method, const char *resource,
174 int *user_data);
175 static const char *quote_string(const char *s, char *q, size_t qsize);
176 static void report_attr(ipp_attribute_t *attr);
177 static void report_printer_state(ipp_t *ipp);
178 #if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
179 static int run_as_user(char *argv[], uid_t uid,
180 const char *device_uri, int fd);
181 #endif /* HAVE_GSSAPI && HAVE_XPC */
182 static void sigterm_handler(int sig);
183 static int timeout_cb(http_t *http, void *user_data);
184 static void update_reasons(ipp_attribute_t *attr, const char *s);
185
186
187 /*
188 * 'main()' - Send a file to the printer or server.
189 *
190 * Usage:
191 *
192 * printer-uri job-id user title copies options [file]
193 */
194
195 int /* O - Exit status */
196 main(int argc, /* I - Number of command-line args */
197 char *argv[]) /* I - Command-line arguments */
198 {
199 int i; /* Looping var */
200 int send_options; /* Send job options? */
201 int num_options; /* Number of printer options */
202 cups_option_t *options; /* Printer options */
203 const char *device_uri; /* Device URI */
204 char scheme[255], /* Scheme in URI */
205 hostname[1024], /* Hostname */
206 resource[1024], /* Resource info (printer name) */
207 addrname[256], /* Address name */
208 *optptr, /* Pointer to URI options */
209 *name, /* Name of option */
210 *value, /* Value of option */
211 sep; /* Separator character */
212 int password_tries = 0; /* Password tries */
213 http_addrlist_t *addrlist; /* Address of printer */
214 int snmp_enabled = 1; /* Is SNMP enabled? */
215 int snmp_fd, /* SNMP socket */
216 start_count, /* Page count via SNMP at start */
217 page_count, /* Page count via SNMP */
218 have_supplies; /* Printer supports supply levels? */
219 int num_files; /* Number of files to print */
220 char **files, /* Files to print */
221 *compatfile = NULL; /* Compatibility filename */
222 off_t compatsize = 0; /* Size of compatibility file */
223 int port; /* Port number (not used) */
224 char uri[HTTP_MAX_URI]; /* Updated URI without user/pass */
225 char print_job_name[1024]; /* Update job-name for Print-Job */
226 http_status_t http_status; /* Status of HTTP request */
227 ipp_status_t ipp_status; /* Status of IPP request */
228 http_t *http; /* HTTP connection */
229 ipp_t *request, /* IPP request */
230 *response, /* IPP response */
231 *supported; /* get-printer-attributes response */
232 time_t start_time; /* Time of first connect */
233 int contimeout; /* Connection timeout */
234 int delay, /* Delay for retries */
235 prev_delay; /* Previous delay */
236 const char *compression; /* Compression mode */
237 int waitjob, /* Wait for job complete? */
238 waitjob_tries = 0, /* Number of times we've waited */
239 waitprinter; /* Wait for printer ready? */
240 time_t waittime; /* Wait time for held jobs */
241 _cups_monitor_t monitor; /* Monitoring data */
242 ipp_attribute_t *job_id_attr; /* job-id attribute */
243 int job_id; /* job-id value */
244 ipp_attribute_t *job_sheets; /* job-media-sheets-completed */
245 ipp_attribute_t *job_state; /* job-state */
246 #ifdef HAVE_LIBZ
247 ipp_attribute_t *compression_sup; /* compression-supported */
248 #endif /* HAVE_LIBZ */
249 ipp_attribute_t *copies_sup; /* copies-supported */
250 ipp_attribute_t *cups_version; /* cups-version */
251 ipp_attribute_t *encryption_sup; /* job-password-encryption-supported */
252 ipp_attribute_t *format_sup; /* document-format-supported */
253 ipp_attribute_t *job_auth; /* job-authorization-uri */
254 ipp_attribute_t *media_col_sup; /* media-col-supported */
255 ipp_attribute_t *operations_sup; /* operations-supported */
256 ipp_attribute_t *doc_handling_sup; /* multiple-document-handling-supported */
257 ipp_attribute_t *printer_state; /* printer-state attribute */
258 ipp_attribute_t *printer_accepting; /* printer-is-accepting-jobs */
259 ipp_attribute_t *print_color_mode_sup;/* Does printer support print-color-mode? */
260 int create_job = 0, /* Does printer support Create-Job? */
261 get_job_attrs = 0, /* Does printer support Get-Job-Attributes? */
262 send_document = 0, /* Does printer support Send-Document? */
263 validate_job = 0, /* Does printer support Validate-Job? */
264 copies, /* Number of copies for job */
265 copies_remaining; /* Number of copies remaining */
266 const char *content_type, /* CONTENT_TYPE environment variable */
267 *final_content_type, /* FINAL_CONTENT_TYPE environment var */
268 *document_format; /* document-format value */
269 int fd; /* File descriptor */
270 off_t bytes = 0; /* Bytes copied */
271 char buffer[16384]; /* Copy buffer */
272 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
273 struct sigaction action; /* Actions for POSIX signals */
274 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
275 int version; /* IPP version */
276 ppd_file_t *ppd = NULL; /* PPD file */
277 _ppd_cache_t *pc = NULL; /* PPD cache and mapping data */
278 fd_set input; /* Input set for select() */
279
280
281 /*
282 * Make sure status messages are not buffered...
283 */
284
285 setbuf(stderr, NULL);
286
287 /*
288 * Ignore SIGPIPE and catch SIGTERM signals...
289 */
290
291 #ifdef HAVE_SIGSET
292 sigset(SIGPIPE, SIG_IGN);
293 sigset(SIGTERM, sigterm_handler);
294 #elif defined(HAVE_SIGACTION)
295 memset(&action, 0, sizeof(action));
296 action.sa_handler = SIG_IGN;
297 sigaction(SIGPIPE, &action, NULL);
298
299 sigemptyset(&action.sa_mask);
300 sigaddset(&action.sa_mask, SIGTERM);
301 action.sa_handler = sigterm_handler;
302 sigaction(SIGTERM, &action, NULL);
303 #else
304 signal(SIGPIPE, SIG_IGN);
305 signal(SIGTERM, sigterm_handler);
306 #endif /* HAVE_SIGSET */
307
308 /*
309 * Check command-line...
310 */
311
312 if (argc == 1)
313 {
314 char *s;
315
316 if ((s = strrchr(argv[0], '/')) != NULL)
317 s ++;
318 else
319 s = argv[0];
320
321 printf("network %s \"Unknown\" \"%s (%s)\"\n",
322 s, _cupsLangString(cupsLangDefault(),
323 _("Internet Printing Protocol")), s);
324 return (CUPS_BACKEND_OK);
325 }
326 else if (argc < 6)
327 {
328 _cupsLangPrintf(stderr,
329 _("Usage: %s job-id user title copies options [file]"),
330 argv[0]);
331 return (CUPS_BACKEND_STOP);
332 }
333
334 /*
335 * Get the device URI...
336 */
337
338 while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
339 {
340 _cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
341 sleep(10);
342
343 if (getenv("CLASS") != NULL)
344 return (CUPS_BACKEND_FAILED);
345 }
346
347 if ((auth_info_required = getenv("AUTH_INFO_REQUIRED")) == NULL)
348 auth_info_required = "none";
349
350 state_reasons = _cupsArrayNewStrings(getenv("PRINTER_STATE_REASONS"), ',');
351
352 #ifdef HAVE_GSSAPI
353 /*
354 * For Kerberos, become the printing user (if we can) to get the credentials
355 * that way.
356 */
357
358 if (!getuid() && (value = getenv("AUTH_UID")) != NULL &&
359 !getenv("AUTH_PASSWORD"))
360 {
361 uid_t uid = (uid_t)atoi(value);
362 /* User ID */
363
364 # ifdef HAVE_XPC
365 if (uid > 0)
366 {
367 if (argc == 6)
368 return (run_as_user(argv, uid, device_uri, 0));
369 else
370 {
371 int status = 0; /* Exit status */
372
373 for (i = 6; i < argc && !status && !job_canceled; i ++)
374 {
375 if ((fd = open(argv[i], O_RDONLY)) >= 0)
376 {
377 status = run_as_user(argv, uid, device_uri, fd);
378 close(fd);
379 }
380 else
381 {
382 _cupsLangPrintError("ERROR", _("Unable to open print file"));
383 status = CUPS_BACKEND_FAILED;
384 }
385 }
386
387 return (status);
388 }
389 }
390
391 # else /* No XPC, just try to run as the user ID */
392 if (uid > 0)
393 seteuid(uid);
394 # endif /* HAVE_XPC */
395 }
396 #endif /* HAVE_GSSAPI */
397
398 /*
399 * Get the (final) content type...
400 */
401
402 if ((content_type = getenv("CONTENT_TYPE")) == NULL)
403 content_type = "application/octet-stream";
404
405 if ((final_content_type = getenv("FINAL_CONTENT_TYPE")) == NULL)
406 {
407 final_content_type = content_type;
408
409 if (!strncmp(final_content_type, "printer/", 8))
410 final_content_type = "application/vnd.cups-raw";
411 }
412
413 /*
414 * Extract the hostname and printer name from the URI...
415 */
416
417 httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
418 username, sizeof(username), hostname, sizeof(hostname), &port,
419 resource, sizeof(resource));
420
421 if (!port)
422 port = IPP_PORT; /* Default to port 631 */
423
424 if (!strcmp(scheme, "https") || !strcmp(scheme, "ipps"))
425 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
426 else
427 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
428
429 /*
430 * See if there are any options...
431 */
432
433 compression = NULL;
434 version = 20;
435 waitjob = 1;
436 waitprinter = 1;
437 contimeout = 7 * 24 * 60 * 60;
438
439 if ((optptr = strchr(resource, '?')) != NULL)
440 {
441 /*
442 * Yup, terminate the device name string and move to the first
443 * character of the optptr...
444 */
445
446 *optptr++ = '\0';
447
448 /*
449 * Then parse the optptr...
450 */
451
452 while (*optptr)
453 {
454 /*
455 * Get the name...
456 */
457
458 name = optptr;
459
460 while (*optptr && *optptr != '=' && *optptr != '+' && *optptr != '&')
461 optptr ++;
462
463 if ((sep = *optptr) != '\0')
464 *optptr++ = '\0';
465
466 if (sep == '=')
467 {
468 /*
469 * Get the value...
470 */
471
472 value = optptr;
473
474 while (*optptr && *optptr != '+' && *optptr != '&')
475 optptr ++;
476
477 if (*optptr)
478 *optptr++ = '\0';
479 }
480 else
481 value = (char *)"";
482
483 /*
484 * Process the option...
485 */
486
487 if (!_cups_strcasecmp(name, "waitjob"))
488 {
489 /*
490 * Wait for job completion?
491 */
492
493 waitjob = !_cups_strcasecmp(value, "on") ||
494 !_cups_strcasecmp(value, "yes") ||
495 !_cups_strcasecmp(value, "true");
496 }
497 else if (!_cups_strcasecmp(name, "waitprinter"))
498 {
499 /*
500 * Wait for printer idle?
501 */
502
503 waitprinter = !_cups_strcasecmp(value, "on") ||
504 !_cups_strcasecmp(value, "yes") ||
505 !_cups_strcasecmp(value, "true");
506 }
507 else if (!_cups_strcasecmp(name, "encryption"))
508 {
509 /*
510 * Enable/disable encryption?
511 */
512
513 if (!_cups_strcasecmp(value, "always"))
514 cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
515 else if (!_cups_strcasecmp(value, "required"))
516 cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
517 else if (!_cups_strcasecmp(value, "never"))
518 cupsSetEncryption(HTTP_ENCRYPT_NEVER);
519 else if (!_cups_strcasecmp(value, "ifrequested"))
520 cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
521 else
522 {
523 _cupsLangPrintFilter(stderr, "ERROR",
524 _("Unknown encryption option value: \"%s\"."),
525 value);
526 }
527 }
528 else if (!_cups_strcasecmp(name, "snmp"))
529 {
530 /*
531 * Enable/disable SNMP stuff...
532 */
533
534 snmp_enabled = !value[0] || !_cups_strcasecmp(value, "on") ||
535 !_cups_strcasecmp(value, "yes") ||
536 !_cups_strcasecmp(value, "true");
537 }
538 else if (!_cups_strcasecmp(name, "version"))
539 {
540 if (!strcmp(value, "1.0"))
541 version = 10;
542 else if (!strcmp(value, "1.1"))
543 version = 11;
544 else if (!strcmp(value, "2.0"))
545 version = 20;
546 else if (!strcmp(value, "2.1"))
547 version = 21;
548 else if (!strcmp(value, "2.2"))
549 version = 22;
550 else
551 {
552 _cupsLangPrintFilter(stderr, "ERROR",
553 _("Unknown version option value: \"%s\"."),
554 value);
555 }
556 }
557 #ifdef HAVE_LIBZ
558 else if (!_cups_strcasecmp(name, "compression"))
559 {
560 if (!_cups_strcasecmp(value, "true") || !_cups_strcasecmp(value, "yes") ||
561 !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "gzip"))
562 compression = "gzip";
563 else if (!_cups_strcasecmp(value, "deflate"))
564 compression = "deflate";
565 else if (!_cups_strcasecmp(value, "false") ||
566 !_cups_strcasecmp(value, "no") ||
567 !_cups_strcasecmp(value, "off") ||
568 !_cups_strcasecmp(value, "none"))
569 compression = "none";
570 }
571 #endif /* HAVE_LIBZ */
572 else if (!_cups_strcasecmp(name, "contimeout"))
573 {
574 /*
575 * Set the connection timeout...
576 */
577
578 if (atoi(value) > 0)
579 contimeout = atoi(value);
580 }
581 else
582 {
583 /*
584 * Unknown option...
585 */
586
587 _cupsLangPrintFilter(stderr, "ERROR",
588 _("Unknown option \"%s\" with value \"%s\"."),
589 name, value);
590 }
591 }
592 }
593
594 /*
595 * If we have 7 arguments, print the file named on the command-line.
596 * Otherwise, copy stdin to a temporary file and print the temporary
597 * file.
598 */
599
600 if (argc == 6)
601 {
602 num_files = 0;
603 files = NULL;
604 send_options = !_cups_strcasecmp(final_content_type, "application/pdf") ||
605 !_cups_strcasecmp(final_content_type, "application/vnd.cups-pdf") ||
606 !_cups_strncasecmp(final_content_type, "image/", 6);
607
608 fputs("DEBUG: Sending stdin for job...\n", stderr);
609 }
610 else
611 {
612 /*
613 * Point to the files on the command-line...
614 */
615
616 num_files = argc - 6;
617 files = argv + 6;
618 send_options = 1;
619
620 fprintf(stderr, "DEBUG: %d files to send in job...\n", num_files);
621 }
622
623 /*
624 * Set the authentication info, if any...
625 */
626
627 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
628
629 if (username[0])
630 {
631 /*
632 * Use authentication information in the device URI...
633 */
634
635 if ((password = strchr(username, ':')) != NULL)
636 *password++ = '\0';
637
638 cupsSetUser(username);
639 uri_credentials = 1;
640 }
641 else
642 {
643 /*
644 * Try loading authentication information from the environment.
645 */
646
647 const char *ptr = getenv("AUTH_USERNAME");
648
649 if (ptr)
650 {
651 strlcpy(username, ptr, sizeof(username));
652 cupsSetUser(ptr);
653 }
654
655 password = getenv("AUTH_PASSWORD");
656 }
657
658 /*
659 * Try finding the remote server...
660 */
661
662 start_time = time(NULL);
663
664 addrlist = backendLookup(hostname, port, &job_canceled);
665
666 http = httpConnect2(hostname, port, addrlist, AF_UNSPEC, cupsEncryption(), 1,
667 0, NULL);
668 httpSetTimeout(http, 30.0, timeout_cb, NULL);
669
670 /*
671 * See if the printer supports SNMP...
672 */
673
674 if (snmp_enabled)
675 snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family);
676 else
677 snmp_fd = -1;
678
679 if (snmp_fd >= 0)
680 have_supplies = !backendSNMPSupplies(snmp_fd, &(addrlist->addr),
681 &start_count, NULL);
682 else
683 have_supplies = start_count = 0;
684
685 /*
686 * Wait for data from the filter...
687 */
688
689 if (num_files == 0)
690 {
691 if (!backendWaitLoop(snmp_fd, &(addrlist->addr), 0, backendNetworkSideCB))
692 return (CUPS_BACKEND_OK);
693 else if ((bytes = read(0, buffer, sizeof(buffer))) <= 0)
694 return (CUPS_BACKEND_OK);
695 }
696
697 /*
698 * Try connecting to the remote server...
699 */
700
701 delay = _cupsNextDelay(0, &prev_delay);
702
703 do
704 {
705 fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
706 _cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
707
708 if (httpReconnect(http))
709 {
710 int error = errno; /* Connection error */
711
712 if (http->status == HTTP_PKI_ERROR)
713 update_reasons(NULL, "+cups-certificate-error");
714
715 if (job_canceled)
716 break;
717
718 if (getenv("CLASS") != NULL)
719 {
720 /*
721 * If the CLASS environment variable is set, the job was submitted
722 * to a class and not to a specific queue. In this case, we want
723 * to abort immediately so that the job can be requeued on the next
724 * available printer in the class.
725 */
726
727 _cupsLangPrintFilter(stderr, "INFO",
728 _("Unable to contact printer, queuing on next "
729 "printer in class."));
730
731 /*
732 * Sleep 5 seconds to keep the job from requeuing too rapidly...
733 */
734
735 sleep(5);
736
737 update_reasons(NULL, "-connecting-to-device");
738
739 return (CUPS_BACKEND_FAILED);
740 }
741
742 fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
743
744 if (errno == ECONNREFUSED || errno == EHOSTDOWN || errno == EHOSTUNREACH || errno == ETIMEDOUT || errno == ENOTCONN)
745 {
746 if (contimeout && (time(NULL) - start_time) > contimeout)
747 {
748 _cupsLangPrintFilter(stderr, "ERROR",
749 _("The printer is not responding."));
750 update_reasons(NULL, "-connecting-to-device");
751 return (CUPS_BACKEND_FAILED);
752 }
753
754 switch (error)
755 {
756 case EHOSTDOWN :
757 _cupsLangPrintFilter(stderr, "WARNING",
758 _("The printer may not exist or "
759 "is unavailable at this time."));
760 break;
761
762 case EHOSTUNREACH :
763 default :
764 _cupsLangPrintFilter(stderr, "WARNING",
765 _("The printer is unreachable at this "
766 "time."));
767 break;
768
769 case ECONNREFUSED :
770 _cupsLangPrintFilter(stderr, "WARNING",
771 _("The printer is in use."));
772 break;
773 }
774
775 sleep((unsigned)delay);
776
777 delay = _cupsNextDelay(delay, &prev_delay);
778 }
779 else
780 {
781 _cupsLangPrintFilter(stderr, "ERROR",
782 _("The printer is not responding."));
783 sleep(30);
784 }
785
786 if (job_canceled)
787 break;
788 }
789 else
790 update_reasons(NULL, "-cups-certificate-error");
791 }
792 while (http->fd < 0);
793
794 if (job_canceled)
795 return (CUPS_BACKEND_OK);
796 else if (!http)
797 return (CUPS_BACKEND_FAILED);
798
799 if (httpIsEncrypted(http))
800 {
801 /*
802 * Validate TLS credentials...
803 */
804
805 cups_array_t *creds; /* TLS credentials */
806 cups_array_t *lcreds = NULL; /* Loaded credentials */
807 http_trust_t trust; /* Trust level */
808 char credinfo[1024], /* Information on credentials */
809 lcredinfo[1024];/* Information on saved credentials */
810 static const char * const trusts[] = { NULL, "+cups-pki-invalid", "+cups-pki-changed", "+cups-pki-expired", NULL, "+cups-pki-unknown" };
811 /* Trust keywords */
812 static const char * const trust_msgs[] =
813 {
814 "Credentials are OK/trusted",
815 "Credentials are invalid",
816 "Credentials have changed",
817 "Credentials are expired",
818 "Credentials have been renewed",
819 "Credentials are unknown/new"
820 };
821
822 fputs("DEBUG: Connection is encrypted.\n", stderr);
823
824 if (!httpCopyCredentials(http, &creds))
825 {
826 trust = httpCredentialsGetTrust(creds, hostname);
827 httpCredentialsString(creds, credinfo, sizeof(credinfo));
828
829 fprintf(stderr, "DEBUG: %s (%s)\n", trust_msgs[trust], cupsLastErrorString());
830 fprintf(stderr, "DEBUG: Printer credentials: %s\n", credinfo);
831
832 if (!httpLoadCredentials(NULL, &lcreds, hostname))
833 {
834 httpCredentialsString(lcreds, lcredinfo, sizeof(lcredinfo));
835 fprintf(stderr, "DEBUG: Stored credentials: %s\n", lcredinfo);
836 }
837 else
838 fputs("DEBUG: No stored credentials.\n", stderr);
839
840 update_reasons(NULL, "-cups-pki-invalid,cups-pki-changed,cups-pki-expired,cups-pki-unknown");
841 if (trusts[trust])
842 {
843 update_reasons(NULL, trusts[trust]);
844 return (CUPS_BACKEND_STOP);
845 }
846
847 if (!lcreds)
848 {
849 /*
850 * Could not load the credentials, let's save the ones we have so we
851 * can detect changes...
852 */
853
854 httpSaveCredentials(NULL, creds, hostname);
855 }
856
857 httpFreeCredentials(lcreds);
858 httpFreeCredentials(creds);
859 }
860 else
861 {
862 fputs("DEBUG: No printer credentials.\n", stderr);
863
864 update_reasons(NULL, "cups-pki-unknown");
865 return (CUPS_BACKEND_STOP);
866 }
867 }
868
869 update_reasons(NULL, "-connecting-to-device");
870 _cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
871
872 fprintf(stderr, "DEBUG: Connected to %s:%d...\n",
873 httpAddrString(http->hostaddr, addrname, sizeof(addrname)),
874 httpAddrPort(http->hostaddr));
875
876 /*
877 * Build a URI for the printer and fill the standard IPP attributes for
878 * an IPP_PRINT_FILE request. We can't use the URI in argv[0] because it
879 * might contain username:password information...
880 */
881
882 httpAssembleURI(HTTP_URI_CODING_ALL, uri, sizeof(uri), scheme, NULL, hostname,
883 port, resource);
884
885 /*
886 * First validate the destination and see if the device supports multiple
887 * copies...
888 */
889
890 #ifdef HAVE_LIBZ
891 compression_sup = NULL;
892 #endif /* HAVE_LIBZ */
893 copies_sup = NULL;
894 cups_version = NULL;
895 encryption_sup = NULL;
896 format_sup = NULL;
897 media_col_sup = NULL;
898 supported = NULL;
899 operations_sup = NULL;
900 doc_handling_sup = NULL;
901 print_color_mode_sup = NULL;
902
903 do
904 {
905 /*
906 * Check for side-channel requests...
907 */
908
909 backendCheckSideChannel(snmp_fd, http->hostaddr);
910
911 /*
912 * Build the IPP request...
913 */
914
915 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
916 ippSetVersion(request, version / 10, version % 10);
917 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
918 NULL, uri);
919
920 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
921 "requested-attributes", sizeof(pattrs) / sizeof(pattrs[0]),
922 NULL, pattrs);
923
924 /*
925 * Do the request...
926 */
927
928 fputs("DEBUG: Getting supported attributes...\n", stderr);
929
930 if (http->version < HTTP_1_1)
931 {
932 fprintf(stderr, "DEBUG: Printer responded with HTTP version %d.%d.\n",
933 http->version / 100, http->version % 100);
934 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
935 "cups-ipp-wrong-http-version");
936 }
937
938 supported = cupsDoRequest(http, request, resource);
939 ipp_status = cupsLastError();
940
941 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
942 ippErrorString(ipp_status), cupsLastErrorString());
943
944 if (ipp_status <= IPP_OK_CONFLICT)
945 password_tries = 0;
946 else
947 {
948 fprintf(stderr, "DEBUG: Get-Printer-Attributes returned %s.\n",
949 ippErrorString(ipp_status));
950
951 if (ipp_status == IPP_PRINTER_BUSY ||
952 ipp_status == IPP_SERVICE_UNAVAILABLE)
953 {
954 if (contimeout && (time(NULL) - start_time) > contimeout)
955 {
956 _cupsLangPrintFilter(stderr, "ERROR",
957 _("The printer is not responding."));
958 return (CUPS_BACKEND_FAILED);
959 }
960
961 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
962
963 report_printer_state(supported);
964
965 sleep((unsigned)delay);
966
967 delay = _cupsNextDelay(delay, &prev_delay);
968 }
969 else if ((ipp_status == IPP_BAD_REQUEST ||
970 ipp_status == IPP_VERSION_NOT_SUPPORTED) && version > 10)
971 {
972 /*
973 * Switch to IPP/1.1 or IPP/1.0...
974 */
975
976 if (version >= 20)
977 {
978 _cupsLangPrintFilter(stderr, "INFO", _("Preparing to print."));
979 fprintf(stderr,
980 "DEBUG: The printer does not support IPP/%d.%d, trying "
981 "IPP/1.1.\n", version / 10, version % 10);
982 version = 11;
983 }
984 else
985 {
986 _cupsLangPrintFilter(stderr, "INFO", _("Preparing to print."));
987 fprintf(stderr,
988 "DEBUG: The printer does not support IPP/%d.%d, trying "
989 "IPP/1.0.\n", version / 10, version % 10);
990 version = 10;
991 }
992
993 httpReconnect(http);
994 }
995 else if (ipp_status == IPP_NOT_FOUND)
996 {
997 _cupsLangPrintFilter(stderr, "ERROR",
998 _("The printer configuration is incorrect or the "
999 "printer no longer exists."));
1000
1001 ippDelete(supported);
1002
1003 return (CUPS_BACKEND_STOP);
1004 }
1005 else if (ipp_status == IPP_FORBIDDEN ||
1006 ipp_status == IPP_AUTHENTICATION_CANCELED)
1007 {
1008 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1009 /* WWW-Authenticate field value */
1010
1011 if (!strncmp(www_auth, "Negotiate", 9))
1012 auth_info_required = "negotiate";
1013 else if (www_auth[0])
1014 auth_info_required = "username,password";
1015
1016 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
1017 return (CUPS_BACKEND_AUTH_REQUIRED);
1018 }
1019 else if (ipp_status != IPP_NOT_AUTHORIZED)
1020 {
1021 _cupsLangPrintFilter(stderr, "ERROR",
1022 _("Unable to get printer status."));
1023 sleep(10);
1024
1025 httpReconnect(http);
1026 }
1027
1028 ippDelete(supported);
1029 supported = NULL;
1030 continue;
1031 }
1032
1033 if (!getenv("CLASS"))
1034 {
1035 /*
1036 * Check printer-is-accepting-jobs = false and printer-state-reasons for the
1037 * "spool-area-full" keyword...
1038 */
1039
1040 int busy = 0;
1041
1042 if ((printer_accepting = ippFindAttribute(supported,
1043 "printer-is-accepting-jobs",
1044 IPP_TAG_BOOLEAN)) != NULL &&
1045 !printer_accepting->values[0].boolean)
1046 busy = 1;
1047 else if (!printer_accepting)
1048 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1049 "cups-ipp-missing-printer-is-accepting-jobs");
1050
1051 if ((printer_state = ippFindAttribute(supported,
1052 "printer-state-reasons",
1053 IPP_TAG_KEYWORD)) == NULL)
1054 {
1055 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1056 "cups-ipp-missing-printer-state-reasons");
1057 }
1058 else if (!busy)
1059 {
1060 for (i = 0; i < printer_state->num_values; i ++)
1061 {
1062 if (!strcmp(printer_state->values[0].string.text,
1063 "spool-area-full") ||
1064 !strncmp(printer_state->values[0].string.text, "spool-area-full-",
1065 16))
1066 {
1067 busy = 1;
1068 break;
1069 }
1070 }
1071 }
1072
1073 if (busy)
1074 {
1075 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
1076
1077 report_printer_state(supported);
1078
1079 sleep((unsigned)delay);
1080
1081 delay = _cupsNextDelay(delay, &prev_delay);
1082
1083 ippDelete(supported);
1084 supported = NULL;
1085 ipp_status = IPP_STATUS_ERROR_BUSY;
1086 continue;
1087 }
1088 }
1089
1090 /*
1091 * Check for supported attributes...
1092 */
1093
1094 #ifdef HAVE_LIBZ
1095 if ((compression_sup = ippFindAttribute(supported, "compression-supported",
1096 IPP_TAG_KEYWORD)) != NULL)
1097 {
1098 /*
1099 * Check whether the requested compression is supported and/or default to
1100 * compression if supported...
1101 */
1102
1103 if (compression && !ippContainsString(compression_sup, compression))
1104 {
1105 fprintf(stderr, "DEBUG: Printer does not support the requested "
1106 "compression value \"%s\".\n", compression);
1107 compression = NULL;
1108 }
1109 else if (!compression && (!strcmp(final_content_type, "image/pwg-raster") || !strcmp(final_content_type, "image/urf")))
1110 {
1111 if (ippContainsString(compression_sup, "gzip"))
1112 compression = "gzip";
1113 else if (ippContainsString(compression_sup, "deflate"))
1114 compression = "deflate";
1115
1116 if (compression)
1117 fprintf(stderr, "DEBUG: Automatically using \"%s\" compression.\n",
1118 compression);
1119 }
1120 }
1121 #endif /* HAVE_LIBZ */
1122
1123 if ((copies_sup = ippFindAttribute(supported, "copies-supported",
1124 IPP_TAG_RANGE)) != NULL)
1125 {
1126 /*
1127 * Has the "copies-supported" attribute - does it have an upper
1128 * bound > 1?
1129 */
1130
1131 fprintf(stderr, "DEBUG: copies-supported=%d-%d\n",
1132 copies_sup->values[0].range.lower,
1133 copies_sup->values[0].range.upper);
1134
1135 if (copies_sup->values[0].range.upper <= 1)
1136 copies_sup = NULL; /* No */
1137 }
1138
1139 cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT);
1140
1141 encryption_sup = ippFindAttribute(supported, "job-password-encryption-supported", IPP_TAG_KEYWORD);
1142
1143 if ((format_sup = ippFindAttribute(supported, "document-format-supported",
1144 IPP_TAG_MIMETYPE)) != NULL)
1145 {
1146 fprintf(stderr, "DEBUG: document-format-supported (%d values)\n",
1147 format_sup->num_values);
1148 for (i = 0; i < format_sup->num_values; i ++)
1149 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
1150 format_sup->values[i].string.text);
1151 }
1152
1153 if ((media_col_sup = ippFindAttribute(supported, "media-col-supported",
1154 IPP_TAG_KEYWORD)) != NULL)
1155 {
1156 fprintf(stderr, "DEBUG: media-col-supported (%d values)\n",
1157 media_col_sup->num_values);
1158 for (i = 0; i < media_col_sup->num_values; i ++)
1159 fprintf(stderr, "DEBUG: [%d] = \"%s\"\n", i,
1160 media_col_sup->values[i].string.text);
1161 }
1162
1163 print_color_mode_sup = ippFindAttribute(supported, "print-color-mode-supported", IPP_TAG_KEYWORD);
1164
1165 if ((operations_sup = ippFindAttribute(supported, "operations-supported",
1166 IPP_TAG_ENUM)) != NULL)
1167 {
1168 fprintf(stderr, "DEBUG: operations-supported (%d values)\n",
1169 operations_sup->num_values);
1170 for (i = 0; i < operations_sup->num_values; i ++)
1171 fprintf(stderr, "DEBUG: [%d] = %s\n", i,
1172 ippOpString(operations_sup->values[i].integer));
1173
1174 for (i = 0; i < operations_sup->num_values; i ++)
1175 if (operations_sup->values[i].integer == IPP_PRINT_JOB)
1176 break;
1177
1178 if (i >= operations_sup->num_values)
1179 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1180 "cups-ipp-missing-print-job");
1181
1182 for (i = 0; i < operations_sup->num_values; i ++)
1183 if (operations_sup->values[i].integer == IPP_CANCEL_JOB)
1184 break;
1185
1186 if (i >= operations_sup->num_values)
1187 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1188 "cups-ipp-missing-cancel-job");
1189
1190 for (i = 0; i < operations_sup->num_values; i ++)
1191 if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
1192 break;
1193
1194 if (i >= operations_sup->num_values)
1195 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1196 "cups-ipp-missing-get-job-attributes");
1197
1198 for (i = 0; i < operations_sup->num_values; i ++)
1199 if (operations_sup->values[i].integer == IPP_GET_PRINTER_ATTRIBUTES)
1200 break;
1201
1202 if (i >= operations_sup->num_values)
1203 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1204 "cups-ipp-missing-get-printer-attributes");
1205
1206 for (i = 0; i < operations_sup->num_values; i ++)
1207 {
1208 if (operations_sup->values[i].integer == IPP_VALIDATE_JOB)
1209 validate_job = 1;
1210 else if (operations_sup->values[i].integer == IPP_CREATE_JOB)
1211 create_job = 1;
1212 else if (operations_sup->values[i].integer == IPP_SEND_DOCUMENT)
1213 send_document = 1;
1214 else if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
1215 get_job_attrs = 1;
1216 }
1217
1218 if (create_job && !send_document)
1219 {
1220 fputs("DEBUG: Printer supports Create-Job but not Send-Document.\n",
1221 stderr);
1222 create_job = 0;
1223
1224 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1225 "cups-ipp-missing-send-document");
1226 }
1227
1228 if (!validate_job)
1229 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1230 "cups-ipp-missing-validate-job");
1231 }
1232 else
1233 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1234 "cups-ipp-missing-operations-supported");
1235
1236 doc_handling_sup = ippFindAttribute(supported,
1237 "multiple-document-handling-supported",
1238 IPP_TAG_KEYWORD);
1239
1240 report_printer_state(supported);
1241 }
1242 while (!job_canceled && ipp_status > IPP_OK_CONFLICT);
1243
1244 if (job_canceled)
1245 return (CUPS_BACKEND_OK);
1246
1247 /*
1248 * See if the printer is accepting jobs and is not stopped; if either
1249 * condition is true and we are printing to a class, requeue the job...
1250 */
1251
1252 if (getenv("CLASS") != NULL)
1253 {
1254 printer_state = ippFindAttribute(supported, "printer-state",
1255 IPP_TAG_ENUM);
1256 printer_accepting = ippFindAttribute(supported, "printer-is-accepting-jobs",
1257 IPP_TAG_BOOLEAN);
1258
1259 if (printer_state == NULL ||
1260 (printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
1261 waitprinter) ||
1262 printer_accepting == NULL ||
1263 !printer_accepting->values[0].boolean)
1264 {
1265 /*
1266 * If the CLASS environment variable is set, the job was submitted
1267 * to a class and not to a specific queue. In this case, we want
1268 * to abort immediately so that the job can be requeued on the next
1269 * available printer in the class.
1270 */
1271
1272 _cupsLangPrintFilter(stderr, "INFO",
1273 _("Unable to contact printer, queuing on next "
1274 "printer in class."));
1275
1276 ippDelete(supported);
1277 httpClose(http);
1278
1279 /*
1280 * Sleep 5 seconds to keep the job from requeuing too rapidly...
1281 */
1282
1283 sleep(5);
1284
1285 return (CUPS_BACKEND_FAILED);
1286 }
1287 }
1288
1289 /*
1290 * See if the printer supports multiple copies...
1291 */
1292
1293 copies = atoi(argv[4]);
1294
1295 if (copies_sup || argc < 7)
1296 copies_remaining = 1;
1297 else
1298 copies_remaining = copies;
1299
1300 /*
1301 * Prepare remaining printing options...
1302 */
1303
1304 options = NULL;
1305
1306 if (send_options)
1307 {
1308 num_options = cupsParseOptions(argv[5], 0, &options);
1309
1310 if (!cups_version && media_col_sup)
1311 {
1312 /*
1313 * Load the PPD file and generate PWG attribute mapping information...
1314 */
1315
1316 ppd_attr_t *mandatory; /* cupsMandatory value */
1317
1318 ppd = ppdOpenFile(getenv("PPD"));
1319 pc = _ppdCacheCreateWithPPD(ppd);
1320
1321 ppdMarkDefaults(ppd);
1322 cupsMarkOptions(ppd, num_options, options);
1323
1324 if ((mandatory = ppdFindAttr(ppd, "cupsMandatory", NULL)) != NULL)
1325 strlcpy(mandatory_attrs, mandatory->value, sizeof(mandatory_attrs));
1326 }
1327
1328 /*
1329 * Validate job-password/-encryption...
1330 */
1331
1332 if (cupsGetOption("job-password", num_options, options))
1333 {
1334 const char *keyword; /* job-password-encryption value */
1335 static const char * const hashes[] =
1336 { /* List of supported hash algorithms, in order of preference */
1337 "sha-512",
1338 "sha-384",
1339 "sha-512_256",
1340 "sha-512-224",
1341 "sha-256",
1342 "sha-224",
1343 "sha",
1344 "none"
1345 };
1346
1347 if ((keyword = cupsGetOption("job-password-encryption", num_options, options)) == NULL || !ippContainsString(encryption_sup, keyword))
1348 {
1349 /*
1350 * Either no job-password-encryption or the value isn't supported by
1351 * the printer...
1352 */
1353
1354 for (i = 0; i < (int)(sizeof(hashes) / sizeof(hashes[0])); i ++)
1355 if (ippContainsString(encryption_sup, hashes[i]))
1356 break;
1357
1358 if (i < (int)(sizeof(hashes) / sizeof(hashes[0])))
1359 num_options = cupsAddOption("job-password-encryption", hashes[i], num_options, &options);
1360 }
1361 }
1362 }
1363 else
1364 num_options = 0;
1365
1366 document_format = NULL;
1367
1368 if (format_sup != NULL)
1369 {
1370 if (ippContainsString(format_sup, final_content_type))
1371 document_format = final_content_type;
1372 else if (ippContainsString(format_sup, "application/octet-stream"))
1373 document_format = "application/octet-stream";
1374 }
1375
1376 fprintf(stderr, "DEBUG: final_content_type=\"%s\", document_format=\"%s\"\n",
1377 final_content_type, document_format ? document_format : "(null)");
1378
1379 /*
1380 * If the printer does not support HTTP/1.1 (which IPP requires), copy stdin
1381 * to a temporary file so that we can do a HTTP/1.0 submission...
1382 *
1383 * (I hate compatibility hacks!)
1384 */
1385
1386 if (http->version < HTTP_1_1 && num_files == 0)
1387 {
1388 if ((fd = cupsTempFd(tmpfilename, sizeof(tmpfilename))) < 0)
1389 {
1390 perror("DEBUG: Unable to create temporary file");
1391 return (CUPS_BACKEND_FAILED);
1392 }
1393
1394 _cupsLangPrintFilter(stderr, "INFO", _("Copying print data."));
1395
1396 if ((compatsize = write(fd, buffer, (size_t)bytes)) < 0)
1397 {
1398 perror("DEBUG: Unable to write temporary file");
1399 return (CUPS_BACKEND_FAILED);
1400 }
1401
1402 if ((bytes = backendRunLoop(-1, fd, snmp_fd, &(addrlist->addr), 0, 0,
1403 backendNetworkSideCB)) < 0)
1404 return (CUPS_BACKEND_FAILED);
1405
1406 compatsize += bytes;
1407
1408 close(fd);
1409
1410 compatfile = tmpfilename;
1411 files = &compatfile;
1412 num_files = 1;
1413 }
1414 else if (http->version < HTTP_1_1 && num_files == 1)
1415 {
1416 struct stat fileinfo; /* File information */
1417
1418 if (!stat(files[0], &fileinfo))
1419 compatsize = fileinfo.st_size;
1420 }
1421
1422 /*
1423 * If the printer only claims to support IPP/1.0, or if the user specifically
1424 * included version=1.0 in the URI, then do not try to use Create-Job or
1425 * Send-Document. This is another dreaded compatibility hack, but
1426 * unfortunately there are enough broken printers out there that we need
1427 * this for now...
1428 */
1429
1430 if (version == 10)
1431 create_job = send_document = 0;
1432
1433 /*
1434 * Start monitoring the printer in the background...
1435 */
1436
1437 monitor.uri = uri;
1438 monitor.hostname = hostname;
1439 monitor.user = argv[2];
1440 monitor.resource = resource;
1441 monitor.port = port;
1442 monitor.version = version;
1443 monitor.job_id = 0;
1444 monitor.create_job = create_job;
1445 monitor.get_job_attrs = get_job_attrs;
1446 monitor.encryption = cupsEncryption();
1447 monitor.job_state = IPP_JOB_PENDING;
1448 monitor.printer_state = IPP_PRINTER_IDLE;
1449
1450 if (create_job)
1451 {
1452 monitor.job_name = argv[3];
1453 }
1454 else
1455 {
1456 snprintf(print_job_name, sizeof(print_job_name), "%s - %s", argv[1],
1457 argv[3]);
1458 monitor.job_name = print_job_name;
1459 }
1460
1461 _cupsThreadCreate((_cups_thread_func_t)monitor_printer, &monitor);
1462
1463 /*
1464 * Validate access to the printer...
1465 */
1466
1467 while (!job_canceled && validate_job)
1468 {
1469 request = new_request(IPP_OP_VALIDATE_JOB, version, uri, argv[2],
1470 monitor.job_name, num_options, options, compression,
1471 copies_sup ? copies : 1, document_format, pc, ppd,
1472 media_col_sup, doc_handling_sup, print_color_mode_sup);
1473
1474 response = cupsDoRequest(http, request, resource);
1475
1476 ipp_status = cupsLastError();
1477
1478 fprintf(stderr, "DEBUG: Validate-Job: %s (%s)\n",
1479 ippErrorString(ipp_status), cupsLastErrorString());
1480 debug_attributes(response);
1481
1482 if ((job_auth = ippFindAttribute(response, "job-authorization-uri",
1483 IPP_TAG_URI)) != NULL)
1484 num_options = cupsAddOption("job-authorization-uri",
1485 ippGetString(job_auth, 0, NULL), num_options,
1486 &options);
1487
1488 ippDelete(response);
1489
1490 if (job_canceled)
1491 break;
1492
1493 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1494 ipp_status == IPP_STATUS_ERROR_BUSY)
1495 {
1496 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
1497 sleep(10);
1498 }
1499 else if (ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED ||
1500 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
1501 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1502 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1503 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1504 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
1505 goto cleanup;
1506 else if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1507 ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
1508 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
1509 {
1510 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1511 /* WWW-Authenticate field value */
1512
1513 if (!strncmp(www_auth, "Negotiate", 9))
1514 auth_info_required = "negotiate";
1515 else if (www_auth[0])
1516 auth_info_required = "username,password";
1517
1518 goto cleanup;
1519 }
1520 else if (ipp_status == IPP_STATUS_ERROR_OPERATION_NOT_SUPPORTED)
1521 {
1522 /*
1523 * This is all too common...
1524 */
1525
1526 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1527 "cups-ipp-missing-validate-job");
1528 break;
1529 }
1530 else if (ipp_status < IPP_REDIRECTION_OTHER_SITE ||
1531 ipp_status == IPP_BAD_REQUEST)
1532 break;
1533 else if (job_auth == NULL && ipp_status > IPP_BAD_REQUEST)
1534 goto cleanup;
1535 }
1536
1537 /*
1538 * Then issue the print-job request...
1539 */
1540
1541 job_id = 0;
1542
1543 while (!job_canceled && copies_remaining > 0)
1544 {
1545 /*
1546 * Check for side-channel requests...
1547 */
1548
1549 backendCheckSideChannel(snmp_fd, http->hostaddr);
1550
1551 /*
1552 * Build the IPP job creation request...
1553 */
1554
1555 if (job_canceled)
1556 break;
1557
1558 request = new_request((num_files > 1 || create_job) ? IPP_CREATE_JOB :
1559 IPP_PRINT_JOB,
1560 version, uri, argv[2], monitor.job_name, num_options,
1561 options, compression, copies_sup ? copies : 1,
1562 document_format, pc, ppd, media_col_sup,
1563 doc_handling_sup, print_color_mode_sup);
1564
1565 /*
1566 * Do the request...
1567 */
1568
1569 if (num_files > 1 || create_job)
1570 response = cupsDoRequest(http, request, resource);
1571 else
1572 {
1573 size_t length = 0; /* Length of request */
1574
1575 if (compatsize > 0)
1576 {
1577 fputs("DEBUG: Sending file using HTTP/1.0 Content-Length...\n", stderr);
1578 length = ippLength(request) + (size_t)compatsize;
1579 }
1580 else
1581 fputs("DEBUG: Sending file using HTTP/1.1 chunking...\n", stderr);
1582
1583 http_status = cupsSendRequest(http, request, resource, length);
1584 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1585 {
1586 if (compression && strcmp(compression, "none"))
1587 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1588
1589 if (num_files == 1)
1590 {
1591 if ((fd = open(files[0], O_RDONLY)) < 0)
1592 {
1593 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1594 return (CUPS_BACKEND_FAILED);
1595 }
1596 }
1597 else
1598 {
1599 fd = 0;
1600 http_status = cupsWriteRequestData(http, buffer, (size_t)bytes);
1601 }
1602
1603 while (http_status == HTTP_CONTINUE &&
1604 (!job_canceled || compatsize > 0))
1605 {
1606 /*
1607 * Check for side-channel requests and more print data...
1608 */
1609
1610 FD_ZERO(&input);
1611 FD_SET(fd, &input);
1612 FD_SET(snmp_fd, &input);
1613 FD_SET(CUPS_SC_FD, &input);
1614
1615 while (select(fd > snmp_fd ? fd + 1 : snmp_fd + 1, &input, NULL, NULL,
1616 NULL) <= 0 && !job_canceled);
1617
1618 if (FD_ISSET(snmp_fd, &input))
1619 backendCheckSideChannel(snmp_fd, http->hostaddr);
1620
1621 if (FD_ISSET(fd, &input))
1622 {
1623 if ((bytes = read(fd, buffer, sizeof(buffer))) > 0)
1624 {
1625 fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
1626
1627 if ((http_status = cupsWriteRequestData(http, buffer, (size_t)bytes))
1628 != HTTP_CONTINUE)
1629 break;
1630 }
1631 else if (bytes == 0 || (errno != EINTR && errno != EAGAIN))
1632 break;
1633 }
1634 }
1635
1636 if (http_status == HTTP_ERROR)
1637 fprintf(stderr, "DEBUG: Error writing document data for "
1638 "Print-Job: %s\n", strerror(httpError(http)));
1639
1640 if (num_files == 1)
1641 close(fd);
1642 }
1643
1644 response = cupsGetResponse(http, resource);
1645 ippDelete(request);
1646 }
1647
1648 ipp_status = cupsLastError();
1649
1650 fprintf(stderr, "DEBUG: %s: %s (%s)\n",
1651 (num_files > 1 || create_job) ? "Create-Job" : "Print-Job",
1652 ippErrorString(ipp_status), cupsLastErrorString());
1653 debug_attributes(response);
1654
1655 if (ipp_status > IPP_OK_CONFLICT)
1656 {
1657 job_id = 0;
1658
1659 if (job_canceled)
1660 break;
1661
1662 if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
1663 ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE ||
1664 ipp_status == IPP_STATUS_ERROR_BUSY)
1665 {
1666 _cupsLangPrintFilter(stderr, "INFO", _("The printer is in use."));
1667 sleep(10);
1668
1669 if (num_files == 0)
1670 {
1671 /*
1672 * We can't re-submit when we have no files to print, so exit
1673 * immediately with the right status code...
1674 */
1675
1676 goto cleanup;
1677 }
1678 }
1679 else if (ipp_status == IPP_STATUS_ERROR_JOB_CANCELED ||
1680 ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
1681 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
1682 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1683 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1684 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1685 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
1686 goto cleanup;
1687 else
1688 {
1689 /*
1690 * Update auth-info-required as needed...
1691 */
1692
1693 _cupsLangPrintFilter(stderr, "ERROR",
1694 _("Print job was not accepted."));
1695
1696 if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
1697 ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
1698 {
1699 const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
1700 /* WWW-Authenticate field value */
1701
1702 if (!strncmp(www_auth, "Negotiate", 9))
1703 auth_info_required = "negotiate";
1704 else if (www_auth[0])
1705 auth_info_required = "username,password";
1706 }
1707 else if (ipp_status == IPP_REQUEST_VALUE)
1708 {
1709 /*
1710 * Print file is too large, abort this job...
1711 */
1712
1713 goto cleanup;
1714 }
1715 else
1716 sleep(10);
1717
1718 if (num_files == 0)
1719 {
1720 /*
1721 * We can't re-submit when we have no files to print, so exit
1722 * immediately with the right status code...
1723 */
1724
1725 goto cleanup;
1726 }
1727 }
1728 }
1729 else if ((job_id_attr = ippFindAttribute(response, "job-id",
1730 IPP_TAG_INTEGER)) == NULL)
1731 {
1732 fputs("DEBUG: Print job accepted - job ID unknown.\n", stderr);
1733 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1734 "cups-ipp-missing-job-id");
1735 job_id = 0;
1736 }
1737 else
1738 {
1739 password_tries = 0;
1740 monitor.job_id = job_id = job_id_attr->values[0].integer;
1741 fprintf(stderr, "DEBUG: Print job accepted - job ID %d.\n", job_id);
1742 }
1743
1744 ippDelete(response);
1745
1746 if (job_canceled)
1747 break;
1748
1749 if (job_id && (num_files > 1 || create_job))
1750 {
1751 for (i = 0; num_files == 0 || i < num_files; i ++)
1752 {
1753 /*
1754 * Check for side-channel requests...
1755 */
1756
1757 backendCheckSideChannel(snmp_fd, http->hostaddr);
1758
1759 /*
1760 * Send the next file in the job...
1761 */
1762
1763 request = ippNewRequest(IPP_SEND_DOCUMENT);
1764 ippSetVersion(request, version / 10, version % 10);
1765
1766 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1767 NULL, uri);
1768
1769 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
1770 job_id);
1771
1772 if (argv[2][0])
1773 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
1774 "requesting-user-name", NULL, argv[2]);
1775
1776 ippAddBoolean(request, IPP_TAG_OPERATION, "last-document",
1777 (i + 1) >= num_files);
1778
1779 if (document_format)
1780 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE,
1781 "document-format", NULL, document_format);
1782
1783 if (compression)
1784 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
1785 "compression", NULL, compression);
1786
1787 fprintf(stderr, "DEBUG: Sending file %d using chunking...\n", i + 1);
1788 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10, ippOpString(ippGetOperation(request)), ippGetRequestId(request));
1789 debug_attributes(request);
1790
1791 http_status = cupsSendRequest(http, request, resource, 0);
1792 if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
1793 {
1794 if (compression && strcmp(compression, "none"))
1795 httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
1796
1797 if (num_files == 0)
1798 {
1799 fd = 0;
1800 http_status = cupsWriteRequestData(http, buffer, (size_t)bytes);
1801 }
1802 else
1803 {
1804 if ((fd = open(files[i], O_RDONLY)) < 0)
1805 {
1806 _cupsLangPrintError("ERROR", _("Unable to open print file"));
1807 return (CUPS_BACKEND_FAILED);
1808 }
1809 }
1810 }
1811 else
1812 fd = -1;
1813
1814 if (fd >= 0)
1815 {
1816 while (!job_canceled && http_status == HTTP_CONTINUE &&
1817 (bytes = read(fd, buffer, sizeof(buffer))) > 0)
1818 {
1819 if ((http_status = cupsWriteRequestData(http, buffer, (size_t)bytes))
1820 != HTTP_CONTINUE)
1821 break;
1822 else
1823 {
1824 /*
1825 * Check for side-channel requests...
1826 */
1827
1828 backendCheckSideChannel(snmp_fd, http->hostaddr);
1829 }
1830 }
1831
1832 if (fd > 0)
1833 close(fd);
1834 }
1835
1836 if (http_status == HTTP_ERROR)
1837 fprintf(stderr, "DEBUG: Error writing document data for "
1838 "Send-Document: %s\n", strerror(httpError(http)));
1839
1840 response = cupsGetResponse(http, resource);
1841 ippDelete(request);
1842
1843 fprintf(stderr, "DEBUG: Send-Document: %s (%s)\n",
1844 ippErrorString(cupsLastError()), cupsLastErrorString());
1845 debug_attributes(response);
1846 ippDelete(response);
1847
1848 if (cupsLastError() > IPP_OK_CONFLICT && !job_canceled)
1849 {
1850 ipp_status = cupsLastError();
1851
1852 _cupsLangPrintFilter(stderr, "ERROR",
1853 _("Unable to add document to print job."));
1854 break;
1855 }
1856 else
1857 {
1858 password_tries = 0;
1859
1860 if (num_files == 0 || fd < 0)
1861 break;
1862 }
1863 }
1864 }
1865
1866 if (job_canceled)
1867 break;
1868
1869 if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
1870 {
1871 fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
1872 copies_remaining --;
1873 }
1874 else if ((ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_ERROR || ipp_status == IPP_STATUS_ERROR_DOCUMENT_UNPRINTABLE) &&
1875 argc == 6 &&
1876 document_format && strcmp(document_format, "image/pwg-raster") && strcmp(document_format, "image/urf"))
1877 {
1878 /*
1879 * Need to reprocess the job as raster...
1880 */
1881
1882 fputs("JOBSTATE: cups-retry-as-raster\n", stderr);
1883 if (job_id > 0)
1884 cancel_job(http, uri, job_id, resource, argv[2], version);
1885
1886 goto cleanup;
1887 }
1888 else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
1889 ipp_status == IPP_NOT_POSSIBLE ||
1890 ipp_status == IPP_PRINTER_BUSY)
1891 {
1892 if (argc == 6)
1893 {
1894 /*
1895 * Need to reprocess the entire job; if we have a job ID, cancel the
1896 * job first...
1897 */
1898
1899 if (job_id > 0)
1900 cancel_job(http, uri, job_id, resource, argv[2], version);
1901
1902 goto cleanup;
1903 }
1904 continue;
1905 }
1906 else if (ipp_status == IPP_REQUEST_VALUE ||
1907 ipp_status == IPP_ERROR_JOB_CANCELED ||
1908 ipp_status == IPP_NOT_AUTHORIZED ||
1909 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
1910 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
1911 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
1912 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED ||
1913 ipp_status == IPP_INTERNAL_ERROR)
1914 {
1915 /*
1916 * Print file is too large, job was canceled, we need new
1917 * authentication data, or we had some sort of error...
1918 */
1919
1920 goto cleanup;
1921 }
1922 else if (ipp_status == IPP_STATUS_ERROR_CUPS_UPGRADE_REQUIRED)
1923 {
1924 /*
1925 * Server is configured incorrectly; the policy for Create-Job and
1926 * Send-Document has to be the same (auth or no auth, encryption or
1927 * no encryption). Force the queue to stop since printing will never
1928 * work.
1929 */
1930
1931 fputs("DEBUG: The server or printer is configured incorrectly.\n",
1932 stderr);
1933 fputs("DEBUG: The policy for Create-Job and Send-Document must have the "
1934 "same authentication and encryption requirements.\n", stderr);
1935
1936 ipp_status = IPP_STATUS_ERROR_INTERNAL;
1937
1938 if (job_id > 0)
1939 cancel_job(http, uri, job_id, resource, argv[2], version);
1940
1941 goto cleanup;
1942 }
1943 else if (ipp_status == IPP_NOT_FOUND)
1944 {
1945 /*
1946 * Printer does not actually implement support for Create-Job/
1947 * Send-Document, so log the conformance issue and stop the printer.
1948 */
1949
1950 fputs("DEBUG: This printer claims to support Create-Job and "
1951 "Send-Document, but those operations failed.\n", stderr);
1952 fputs("DEBUG: Add '?version=1.0' to the device URI to use legacy "
1953 "compatibility mode.\n", stderr);
1954 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
1955 "cups-ipp-missing-send-document");
1956
1957 ipp_status = IPP_INTERNAL_ERROR; /* Force queue to stop */
1958
1959 goto cleanup;
1960 }
1961 else
1962 copies_remaining --;
1963
1964 /*
1965 * Wait for the job to complete...
1966 */
1967
1968 if (!job_id || !waitjob || !get_job_attrs)
1969 continue;
1970
1971 fputs("STATE: +cups-waiting-for-job-completed\n", stderr);
1972
1973 _cupsLangPrintFilter(stderr, "INFO", _("Waiting for job to complete."));
1974
1975 for (delay = _cupsNextDelay(0, &prev_delay), waittime = time(NULL) + 30; !job_canceled;)
1976 {
1977 /*
1978 * Check for side-channel requests...
1979 */
1980
1981 backendCheckSideChannel(snmp_fd, http->hostaddr);
1982
1983 /*
1984 * Check printer state...
1985 */
1986
1987 check_printer_state(http, uri, resource, argv[2], version);
1988
1989 if (cupsLastError() <= IPP_OK_CONFLICT)
1990 password_tries = 0;
1991
1992 /*
1993 * Build an IPP_GET_JOB_ATTRIBUTES request...
1994 */
1995
1996 request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
1997 ippSetVersion(request, version / 10, version % 10);
1998
1999 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2000 NULL, uri);
2001
2002 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
2003 job_id);
2004
2005 if (argv[2][0])
2006 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2007 "requesting-user-name", NULL, argv[2]);
2008
2009 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2010 "requested-attributes", sizeof(jattrs) / sizeof(jattrs[0]),
2011 NULL, jattrs);
2012
2013 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10, ippOpString(ippGetOperation(request)), ippGetRequestId(request));
2014 debug_attributes(request);
2015
2016 /*
2017 * Do the request...
2018 */
2019
2020 httpReconnect(http);
2021 response = cupsDoRequest(http, request, resource);
2022 ipp_status = cupsLastError();
2023
2024 if (ipp_status == IPP_NOT_FOUND || ipp_status == IPP_NOT_POSSIBLE)
2025 {
2026 /*
2027 * Job has gone away and/or the server has no job history...
2028 */
2029
2030 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
2031 "cups-ipp-missing-job-history");
2032 ippDelete(response);
2033
2034 ipp_status = IPP_OK;
2035 break;
2036 }
2037
2038 fprintf(stderr, "DEBUG: Get-Job-Attributes: %s (%s)\n",
2039 ippErrorString(ipp_status), cupsLastErrorString());
2040 debug_attributes(response);
2041
2042 if (ipp_status <= IPP_OK_CONFLICT)
2043 password_tries = 0;
2044 else
2045 {
2046 if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
2047 ipp_status != IPP_PRINTER_BUSY)
2048 {
2049 ippDelete(response);
2050 ipp_status = IPP_OK;
2051 break;
2052 }
2053 else if (ipp_status == IPP_INTERNAL_ERROR)
2054 {
2055 waitjob_tries ++;
2056
2057 if (waitjob_tries > 4)
2058 {
2059 ippDelete(response);
2060 ipp_status = IPP_OK;
2061 break;
2062 }
2063 }
2064 }
2065
2066 if (response)
2067 {
2068 if ((job_state = ippFindAttribute(response, "job-state",
2069 IPP_TAG_ENUM)) != NULL)
2070 {
2071 /*
2072 * Reflect the remote job state in the local queue...
2073 */
2074
2075 if (cups_version &&
2076 job_state->values[0].integer >= IPP_JOB_PENDING &&
2077 job_state->values[0].integer <= IPP_JOB_COMPLETED)
2078 update_reasons(NULL,
2079 remote_job_states[job_state->values[0].integer -
2080 IPP_JOB_PENDING]);
2081
2082 if ((job_sheets = ippFindAttribute(response, "job-impressions-completed", IPP_TAG_INTEGER)) == NULL)
2083 job_sheets = ippFindAttribute(response, "job-media-sheets-completed", IPP_TAG_INTEGER);
2084
2085 if (job_sheets)
2086 fprintf(stderr, "PAGE: total %d\n",
2087 job_sheets->values[0].integer);
2088
2089 /*
2090 * Stop polling if the job is finished or pending-held for 30 seconds...
2091 */
2092
2093 if (job_state->values[0].integer > IPP_JSTATE_STOPPED ||
2094 (job_state->values[0].integer == IPP_JSTATE_HELD && time(NULL) > waittime))
2095 {
2096 ippDelete(response);
2097 break;
2098 }
2099 }
2100 else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
2101 ipp_status != IPP_NOT_POSSIBLE &&
2102 ipp_status != IPP_PRINTER_BUSY)
2103 {
2104 /*
2105 * If the printer does not return a job-state attribute, it does not
2106 * conform to the IPP specification - break out immediately and fail
2107 * the job...
2108 */
2109
2110 update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
2111 "cups-ipp-missing-job-state");
2112 ipp_status = IPP_INTERNAL_ERROR;
2113 break;
2114 }
2115 }
2116
2117 ippDelete(response);
2118
2119 /*
2120 * Wait before polling again...
2121 */
2122
2123 sleep((unsigned)delay);
2124
2125 delay = _cupsNextDelay(delay, &prev_delay);
2126 }
2127 }
2128
2129 /*
2130 * Cancel the job as needed...
2131 */
2132
2133 if (job_canceled > 0 && job_id > 0)
2134 {
2135 cancel_job(http, uri, job_id, resource, argv[2], version);
2136
2137 if (cupsLastError() > IPP_OK_CONFLICT)
2138 _cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
2139 }
2140
2141 /*
2142 * Check the printer state and report it if necessary...
2143 */
2144
2145 check_printer_state(http, uri, resource, argv[2], version);
2146
2147 if (cupsLastError() <= IPP_OK_CONFLICT)
2148 password_tries = 0;
2149
2150 /*
2151 * Collect the final page count as needed...
2152 */
2153
2154 if (have_supplies &&
2155 !backendSNMPSupplies(snmp_fd, &(http->addrlist->addr), &page_count,
2156 NULL) &&
2157 page_count > start_count)
2158 fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
2159
2160 #ifdef HAVE_GSSAPI
2161 /*
2162 * See if we used Kerberos at all...
2163 */
2164
2165 if (http->gssctx)
2166 auth_info_required = "negotiate";
2167 #endif /* HAVE_GSSAPI */
2168
2169 /*
2170 * Free memory...
2171 */
2172
2173 cleanup:
2174
2175 cupsFreeOptions(num_options, options);
2176 _ppdCacheDestroy(pc);
2177 ppdClose(ppd);
2178
2179 httpClose(http);
2180
2181 ippDelete(supported);
2182
2183 /*
2184 * Remove the temporary file(s) if necessary...
2185 */
2186
2187 if (tmpfilename[0])
2188 unlink(tmpfilename);
2189
2190 /*
2191 * Return the queue status...
2192 */
2193
2194 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
2195 ipp_status == IPP_AUTHENTICATION_CANCELED ||
2196 ipp_status <= IPP_OK_CONFLICT)
2197 fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
2198
2199 if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED)
2200 fputs("JOBSTATE: account-info-needed\n", stderr);
2201 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED)
2202 fputs("JOBSTATE: account-closed\n", stderr);
2203 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED)
2204 fputs("JOBSTATE: account-limit-reached\n", stderr);
2205 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
2206 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2207
2208 if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
2209 ipp_status == IPP_AUTHENTICATION_CANCELED)
2210 return (CUPS_BACKEND_AUTH_REQUIRED);
2211 else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
2212 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
2213 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
2214 ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
2215 return (CUPS_BACKEND_HOLD);
2216 else if (ipp_status == IPP_INTERNAL_ERROR)
2217 return (CUPS_BACKEND_STOP);
2218 else if (ipp_status == IPP_CONFLICT || ipp_status == IPP_STATUS_ERROR_REQUEST_ENTITY || ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE)
2219 return (CUPS_BACKEND_FAILED);
2220 else if (ipp_status == IPP_REQUEST_VALUE ||
2221 ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
2222 ipp_status == IPP_DOCUMENT_FORMAT || job_canceled < 0)
2223 {
2224 if (ipp_status == IPP_REQUEST_VALUE)
2225 _cupsLangPrintFilter(stderr, "ERROR", _("Print job too large."));
2226 else if (ipp_status == IPP_DOCUMENT_FORMAT)
2227 _cupsLangPrintFilter(stderr, "ERROR",
2228 _("Printer cannot print supplied content."));
2229 else if (ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES)
2230 _cupsLangPrintFilter(stderr, "ERROR",
2231 _("Printer cannot print with supplied options."));
2232 else
2233 _cupsLangPrintFilter(stderr, "ERROR", _("Print job canceled at printer."));
2234
2235 return (CUPS_BACKEND_CANCEL);
2236 }
2237 else if (ipp_status > IPP_OK_CONFLICT && ipp_status != IPP_ERROR_JOB_CANCELED)
2238 return (CUPS_BACKEND_RETRY_CURRENT);
2239 else
2240 return (CUPS_BACKEND_OK);
2241 }
2242
2243
2244 /*
2245 * 'cancel_job()' - Cancel a print job.
2246 */
2247
2248 static void
2249 cancel_job(http_t *http, /* I - HTTP connection */
2250 const char *uri, /* I - printer-uri */
2251 int id, /* I - job-id */
2252 const char *resource, /* I - Resource path */
2253 const char *user, /* I - requesting-user-name */
2254 int version) /* I - IPP version */
2255 {
2256 ipp_t *request; /* Cancel-Job request */
2257
2258
2259 _cupsLangPrintFilter(stderr, "INFO", _("Canceling print job."));
2260
2261 request = ippNewRequest(IPP_CANCEL_JOB);
2262 ippSetVersion(request, version / 10, version % 10);
2263
2264 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2265 NULL, uri);
2266 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", id);
2267
2268 if (user && user[0])
2269 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2270 "requesting-user-name", NULL, user);
2271
2272 /*
2273 * Do the request...
2274 */
2275
2276 ippDelete(cupsDoRequest(http, request, resource));
2277 }
2278
2279
2280 /*
2281 * 'check_printer_state()' - Check the printer state.
2282 */
2283
2284 static ipp_pstate_t /* O - Current printer-state */
2285 check_printer_state(
2286 http_t *http, /* I - HTTP connection */
2287 const char *uri, /* I - Printer URI */
2288 const char *resource, /* I - Resource path */
2289 const char *user, /* I - Username, if any */
2290 int version) /* I - IPP version */
2291 {
2292 ipp_t *request, /* IPP request */
2293 *response; /* IPP response */
2294 ipp_attribute_t *attr; /* Attribute in response */
2295 ipp_pstate_t printer_state = IPP_PRINTER_STOPPED;
2296 /* Current printer-state */
2297
2298
2299 /*
2300 * Send a Get-Printer-Attributes request and log the results...
2301 */
2302
2303 request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
2304 ippSetVersion(request, version / 10, version % 10);
2305
2306 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2307 NULL, uri);
2308
2309 if (user && user[0])
2310 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2311 "requesting-user-name", NULL, user);
2312
2313 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2314 "requested-attributes",
2315 (int)(sizeof(pattrs) / sizeof(pattrs[0])), NULL, pattrs);
2316
2317 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10, ippOpString(ippGetOperation(request)), ippGetRequestId(request));
2318 debug_attributes(request);
2319
2320 if ((response = cupsDoRequest(http, request, resource)) != NULL)
2321 {
2322 report_printer_state(response);
2323
2324 if ((attr = ippFindAttribute(response, "printer-state",
2325 IPP_TAG_ENUM)) != NULL)
2326 printer_state = (ipp_pstate_t)attr->values[0].integer;
2327 }
2328
2329 fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
2330 ippErrorString(cupsLastError()), cupsLastErrorString());
2331 debug_attributes(response);
2332 ippDelete(response);
2333
2334 /*
2335 * Return the printer-state value...
2336 */
2337
2338 return (printer_state);
2339 }
2340
2341
2342 /*
2343 * 'debug_attributes()' - Print out the request or response attributes as DEBUG
2344 * messages...
2345 */
2346
2347 static void
2348 debug_attributes(ipp_t *ipp) /* I - Request or response message */
2349 {
2350 ipp_tag_t group; /* Current group */
2351 ipp_attribute_t *attr; /* Current attribute */
2352 char buffer[1024]; /* Value buffer */
2353
2354
2355 for (group = IPP_TAG_ZERO, attr = ippFirstAttribute(ipp);
2356 attr;
2357 attr = ippNextAttribute(ipp))
2358 {
2359 const char *name = ippGetName(attr);
2360
2361 if (!name)
2362 {
2363 group = IPP_TAG_ZERO;
2364 continue;
2365 }
2366
2367 if (group != ippGetGroupTag(attr))
2368 {
2369 group = ippGetGroupTag(attr);
2370 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(group));
2371 }
2372
2373 if (!strcmp(name, "job-password"))
2374 strlcpy(buffer, "---", sizeof(buffer));
2375 else
2376 ippAttributeString(attr, buffer, sizeof(buffer));
2377
2378 fprintf(stderr, "DEBUG: %s %s%s %s\n", name,
2379 ippGetCount(attr) > 1 ? "1setOf " : "",
2380 ippTagString(ippGetValueTag(attr)), buffer);
2381 }
2382
2383 fprintf(stderr, "DEBUG: ---- %s ----\n", ippTagString(IPP_TAG_END));
2384 }
2385
2386
2387 /*
2388 * 'monitor_printer()' - Monitor the printer state.
2389 */
2390
2391 static void * /* O - Thread exit code */
2392 monitor_printer(
2393 _cups_monitor_t *monitor) /* I - Monitoring data */
2394 {
2395 http_t *http; /* Connection to printer */
2396 ipp_t *request, /* IPP request */
2397 *response; /* IPP response */
2398 ipp_attribute_t *attr; /* Attribute in response */
2399 int delay, /* Current delay */
2400 prev_delay; /* Previous delay */
2401 ipp_op_t job_op; /* Operation to use */
2402 int job_id; /* Job ID */
2403 const char *job_name; /* Job name */
2404 ipp_jstate_t job_state; /* Job state */
2405 const char *job_user; /* Job originating user name */
2406 int password_tries = 0; /* Password tries */
2407
2408
2409 /*
2410 * Make a copy of the printer connection...
2411 */
2412
2413 http = httpConnect2(monitor->hostname, monitor->port, NULL, AF_UNSPEC,
2414 monitor->encryption, 1, 0, NULL);
2415 httpSetTimeout(http, 30.0, timeout_cb, NULL);
2416 if (username[0])
2417 cupsSetUser(username);
2418
2419 cupsSetPasswordCB2((cups_password_cb2_t)password_cb, &password_tries);
2420
2421 /*
2422 * Loop until the job is canceled, aborted, or completed.
2423 */
2424
2425 delay = _cupsNextDelay(0, &prev_delay);
2426
2427 monitor->job_reasons = 0;
2428
2429 while (monitor->job_state < IPP_JOB_CANCELED && !job_canceled)
2430 {
2431 /*
2432 * Reconnect to the printer as needed...
2433 */
2434
2435 if (httpGetFd(http) < 0)
2436 httpReconnect(http);
2437
2438 if (httpGetFd(http) >= 0)
2439 {
2440 /*
2441 * Connected, so check on the printer state...
2442 */
2443
2444 monitor->printer_state = check_printer_state(http, monitor->uri,
2445 monitor->resource,
2446 monitor->user,
2447 monitor->version);
2448 if (cupsLastError() <= IPP_OK_CONFLICT)
2449 password_tries = 0;
2450
2451 if (monitor->job_id == 0 && monitor->create_job)
2452 {
2453 /*
2454 * No job-id yet, so continue...
2455 */
2456
2457 goto monitor_sleep;
2458 }
2459
2460 /*
2461 * Check the status of the job itself...
2462 */
2463
2464 job_op = (monitor->job_id > 0 && monitor->get_job_attrs) ?
2465 IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
2466 request = ippNewRequest(job_op);
2467 ippSetVersion(request, monitor->version / 10, monitor->version % 10);
2468
2469 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
2470 NULL, monitor->uri);
2471 if (job_op == IPP_GET_JOB_ATTRIBUTES)
2472 ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
2473 monitor->job_id);
2474
2475 if (monitor->user && monitor->user[0])
2476 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
2477 "requesting-user-name", NULL, monitor->user);
2478
2479 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
2480 "requested-attributes",
2481 (int)(sizeof(jattrs) / sizeof(jattrs[0])), NULL, jattrs);
2482
2483 /*
2484 * Do the request...
2485 */
2486
2487 response = cupsDoRequest(http, request, monitor->resource);
2488
2489 fprintf(stderr, "DEBUG: (monitor) %s: %s (%s)\n", ippOpString(job_op),
2490 ippErrorString(cupsLastError()), cupsLastErrorString());
2491
2492 if (cupsLastError() <= IPP_OK_CONFLICT)
2493 password_tries = 0;
2494
2495 if (job_op == IPP_GET_JOB_ATTRIBUTES)
2496 {
2497 if ((attr = ippFindAttribute(response, "job-state",
2498 IPP_TAG_ENUM)) != NULL)
2499 monitor->job_state = (ipp_jstate_t)attr->values[0].integer;
2500 else
2501 monitor->job_state = IPP_JOB_COMPLETED;
2502 }
2503 else if (response)
2504 {
2505 for (attr = response->attrs; attr; attr = attr->next)
2506 {
2507 job_id = 0;
2508 job_name = NULL;
2509 job_state = IPP_JOB_PENDING;
2510 job_user = NULL;
2511
2512 while (attr && attr->group_tag != IPP_TAG_JOB)
2513 attr = attr->next;
2514
2515 if (!attr)
2516 break;
2517
2518 while (attr && attr->group_tag == IPP_TAG_JOB)
2519 {
2520 if (!strcmp(attr->name, "job-id") &&
2521 attr->value_tag == IPP_TAG_INTEGER)
2522 job_id = attr->values[0].integer;
2523 else if (!strcmp(attr->name, "job-name") &&
2524 (attr->value_tag == IPP_TAG_NAME ||
2525 attr->value_tag == IPP_TAG_NAMELANG))
2526 job_name = attr->values[0].string.text;
2527 else if (!strcmp(attr->name, "job-state") &&
2528 attr->value_tag == IPP_TAG_ENUM)
2529 job_state = (ipp_jstate_t)attr->values[0].integer;
2530 else if (!strcmp(attr->name, "job-originating-user-name") &&
2531 (attr->value_tag == IPP_TAG_NAME ||
2532 attr->value_tag == IPP_TAG_NAMELANG))
2533 job_user = attr->values[0].string.text;
2534
2535 attr = attr->next;
2536 }
2537
2538 if (job_id > 0 && job_name && !strcmp(job_name, monitor->job_name) &&
2539 job_user && monitor->user && !strcmp(job_user, monitor->user))
2540 {
2541 monitor->job_id = job_id;
2542 monitor->job_state = job_state;
2543 break;
2544 }
2545
2546 if (!attr)
2547 break;
2548 }
2549 }
2550
2551 fprintf(stderr, "DEBUG: (monitor) job-state = %s\n",
2552 ippEnumString("job-state", monitor->job_state));
2553
2554 if (!job_canceled &&
2555 (monitor->job_state == IPP_JOB_CANCELED ||
2556 monitor->job_state == IPP_JOB_ABORTED))
2557 {
2558 job_canceled = -1;
2559 fprintf(stderr, "DEBUG: (monitor) job_canceled = -1\n");
2560 }
2561
2562 if ((attr = ippFindAttribute(response, "job-state-reasons",
2563 IPP_TAG_KEYWORD)) != NULL)
2564 {
2565 int i, new_reasons = 0; /* Looping var, new reasons */
2566
2567 for (i = 0; i < attr->num_values; i ++)
2568 {
2569 if (!strcmp(attr->values[i].string.text,
2570 "account-authorization-failed"))
2571 new_reasons |= _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED;
2572 else if (!strcmp(attr->values[i].string.text, "account-closed"))
2573 new_reasons |= _CUPS_JSR_ACCOUNT_CLOSED;
2574 else if (!strcmp(attr->values[i].string.text, "account-info-needed"))
2575 new_reasons |= _CUPS_JSR_ACCOUNT_INFO_NEEDED;
2576 else if (!strcmp(attr->values[i].string.text,
2577 "account-limit-reached"))
2578 new_reasons |= _CUPS_JSR_ACCOUNT_LIMIT_REACHED;
2579 else if (!strcmp(attr->values[i].string.text, "job-password-wait"))
2580 new_reasons |= _CUPS_JSR_JOB_PASSWORD_WAIT;
2581 else if (!strcmp(attr->values[i].string.text, "job-release-wait"))
2582 new_reasons |= _CUPS_JSR_JOB_RELEASE_WAIT;
2583 if (!job_canceled &&
2584 (!strncmp(attr->values[i].string.text, "job-canceled-", 13) || !strcmp(attr->values[i].string.text, "aborted-by-system")))
2585 job_canceled = 1;
2586 }
2587
2588 if (new_reasons != monitor->job_reasons)
2589 {
2590 if (new_reasons & _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED)
2591 fputs("JOBSTATE: account-authorization-failed\n", stderr);
2592 else if (new_reasons & _CUPS_JSR_ACCOUNT_CLOSED)
2593 fputs("JOBSTATE: account-closed\n", stderr);
2594 else if (new_reasons & _CUPS_JSR_ACCOUNT_INFO_NEEDED)
2595 fputs("JOBSTATE: account-info-needed\n", stderr);
2596 else if (new_reasons & _CUPS_JSR_ACCOUNT_LIMIT_REACHED)
2597 fputs("JOBSTATE: account-limit-reached\n", stderr);
2598 else if (new_reasons & _CUPS_JSR_JOB_PASSWORD_WAIT)
2599 fputs("JOBSTATE: job-password-wait\n", stderr);
2600 else if (new_reasons & _CUPS_JSR_JOB_RELEASE_WAIT)
2601 fputs("JOBSTATE: job-release-wait\n", stderr);
2602 else
2603 fputs("JOBSTATE: job-printing\n", stderr);
2604
2605 monitor->job_reasons = new_reasons;
2606 }
2607 }
2608
2609 ippDelete(response);
2610
2611 fprintf(stderr, "DEBUG: (monitor) job-state = %s\n",
2612 ippEnumString("job-state", monitor->job_state));
2613
2614 if (!job_canceled &&
2615 (monitor->job_state == IPP_JOB_CANCELED ||
2616 monitor->job_state == IPP_JOB_ABORTED))
2617 job_canceled = -1;
2618 }
2619
2620 /*
2621 * Sleep for N seconds...
2622 */
2623
2624 monitor_sleep:
2625
2626 sleep((unsigned)delay);
2627
2628 delay = _cupsNextDelay(delay, &prev_delay);
2629 }
2630
2631 /*
2632 * Cancel the job if necessary...
2633 */
2634
2635 if (job_canceled > 0 && monitor->job_id > 0)
2636 {
2637 if (httpGetFd(http) < 0)
2638 httpReconnect(http);
2639
2640 if (httpGetFd(http) >= 0)
2641 {
2642 cancel_job(http, monitor->uri, monitor->job_id, monitor->resource,
2643 monitor->user, monitor->version);
2644
2645 if (cupsLastError() > IPP_OK_CONFLICT)
2646 {
2647 fprintf(stderr, "DEBUG: (monitor) cancel_job() = %s\n", cupsLastErrorString());
2648 _cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
2649 }
2650 }
2651 }
2652
2653 /*
2654 * Cleanup and return...
2655 */
2656
2657 httpClose(http);
2658
2659 return (NULL);
2660 }
2661
2662
2663 /*
2664 * 'new_request()' - Create a new print creation or validation request.
2665 */
2666
2667 static ipp_t * /* O - Request data */
2668 new_request(
2669 ipp_op_t op, /* I - IPP operation code */
2670 int version, /* I - IPP version number */
2671 const char *uri, /* I - printer-uri value */
2672 const char *user, /* I - requesting-user-name value */
2673 const char *title, /* I - job-name value */
2674 int num_options, /* I - Number of options to send */
2675 cups_option_t *options, /* I - Options to send */
2676 const char *compression, /* I - compression value or NULL */
2677 int copies, /* I - copies value or 0 */
2678 const char *format, /* I - document-format value or NULL */
2679 _ppd_cache_t *pc, /* I - PPD cache and mapping data */
2680 ppd_file_t *ppd, /* I - PPD file data */
2681 ipp_attribute_t *media_col_sup, /* I - media-col-supported values */
2682 ipp_attribute_t *doc_handling_sup, /* I - multiple-document-handling-supported values */
2683 ipp_attribute_t *print_color_mode_sup)
2684 /* I - Printer supports print-color-mode */
2685 {
2686 ipp_t *request; /* Request data */
2687 const char *keyword; /* PWG keyword */
2688
2689
2690 /*
2691 * Create the IPP request...
2692 */
2693
2694 request = ippNewRequest(op);
2695 ippSetVersion(request, version / 10, version % 10);
2696
2697 fprintf(stderr, "DEBUG: %s IPP/%d.%d\n",
2698 ippOpString(request->request.op.operation_id),
2699 request->request.op.version[0],
2700 request->request.op.version[1]);
2701
2702 /*
2703 * Add standard attributes...
2704 */
2705
2706 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
2707 fprintf(stderr, "DEBUG: printer-uri=\"%s\"\n", uri);
2708
2709 if (user && *user)
2710 {
2711 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, user);
2712 fprintf(stderr, "DEBUG: requesting-user-name=\"%s\"\n", user);
2713 }
2714
2715 if (title && *title)
2716 {
2717 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, title);
2718 fprintf(stderr, "DEBUG: job-name=\"%s\"\n", title);
2719 }
2720
2721 if (format && op != IPP_CREATE_JOB)
2722 {
2723 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format", NULL, format);
2724 fprintf(stderr, "DEBUG: document-format=\"%s\"\n", format);
2725 }
2726
2727 #ifdef HAVE_LIBZ
2728 if (compression && op != IPP_OP_CREATE_JOB && op != IPP_OP_VALIDATE_JOB)
2729 {
2730 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "compression", NULL, compression);
2731 fprintf(stderr, "DEBUG: compression=\"%s\"\n", compression);
2732 }
2733 #endif /* HAVE_LIBZ */
2734
2735 /*
2736 * Handle options on the command-line...
2737 */
2738
2739 if (num_options > 0)
2740 {
2741 if (pc)
2742 {
2743 /*
2744 * Send standard IPP attributes...
2745 */
2746
2747 fputs("DEBUG: Adding standard IPP operation/job attributes.\n", stderr);
2748
2749 copies = _cupsConvertOptions(request, ppd, pc, media_col_sup, doc_handling_sup, print_color_mode_sup, user, format, copies, num_options, options);
2750
2751 /*
2752 * Map FaxOut options...
2753 */
2754
2755 if ((keyword = cupsGetOption("phone", num_options, options)) != NULL)
2756 {
2757 ipp_t *destination; /* destination collection */
2758 char phone[1024], /* Phone number string */
2759 *ptr, /* Pointer into string */
2760 tel_uri[1024]; /* tel: URI */
2761 static const char * const allowed = "0123456789#*-+.()";
2762 /* Allowed characters */
2763
2764 destination = ippNew();
2765
2766 /*
2767 * Unescape and filter out spaces and other characters that are not
2768 * allowed in a tel: URI.
2769 */
2770
2771 _httpDecodeURI(phone, keyword, sizeof(phone));
2772 for (ptr = phone; *ptr;)
2773 {
2774 if (!strchr(allowed, *ptr))
2775 _cups_strcpy(ptr, ptr + 1);
2776 else
2777 ptr ++;
2778 }
2779
2780 httpAssembleURI(HTTP_URI_CODING_ALL, tel_uri, sizeof(tel_uri), "tel", NULL, NULL, 0, phone);
2781 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_URI, "destination-uri", NULL, tel_uri);
2782
2783 if ((keyword = cupsGetOption("faxPrefix", num_options,
2784 options)) != NULL && *keyword)
2785 {
2786 char predial[1024]; /* Pre-dial string */
2787
2788 _httpDecodeURI(predial, keyword, sizeof(predial));
2789 ippAddString(destination, IPP_TAG_JOB, IPP_TAG_TEXT, "pre-dial-string", NULL, predial);
2790 }
2791
2792 ippAddCollection(request, IPP_TAG_JOB, "destination-uris", destination);
2793 ippDelete(destination);
2794 }
2795 }
2796 else
2797 {
2798 /*
2799 * When talking to another CUPS server, send all options...
2800 */
2801
2802 fputs("DEBUG: Adding all operation/job attributes.\n", stderr);
2803 cupsEncodeOptions2(request, num_options, options, IPP_TAG_OPERATION);
2804 cupsEncodeOptions2(request, num_options, options, IPP_TAG_JOB);
2805 }
2806
2807 if (copies > 1 && (!pc || copies <= pc->max_copies))
2808 ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", copies);
2809 }
2810
2811 fprintf(stderr, "DEBUG: IPP/%d.%d %s #%d\n", version / 10, version % 10, ippOpString(ippGetOperation(request)), ippGetRequestId(request));
2812 debug_attributes(request);
2813
2814 return (request);
2815 }
2816
2817
2818 /*
2819 * 'password_cb()' - Disable the password prompt for cupsDoFileRequest().
2820 */
2821
2822 static const char * /* O - Password */
2823 password_cb(const char *prompt, /* I - Prompt (not used) */
2824 http_t *http, /* I - Connection */
2825 const char *method, /* I - Request method (not used) */
2826 const char *resource, /* I - Resource path (not used) */
2827 int *password_tries) /* I - Password tries */
2828 {
2829 char def_username[HTTP_MAX_VALUE]; /* Default username */
2830
2831
2832 fprintf(stderr, "DEBUG: password_cb(prompt=\"%s\", http=%p, method=\"%s\", "
2833 "resource=\"%s\", password_tries=%p(%d)), password=%p\n",
2834 prompt, http, method, resource, password_tries, *password_tries,
2835 password);
2836
2837 (void)prompt;
2838 (void)method;
2839 (void)resource;
2840
2841 if (!uri_credentials)
2842 {
2843 /*
2844 * Remember that we need to authenticate...
2845 */
2846
2847 auth_info_required = "username,password";
2848
2849 if (httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "username",
2850 def_username))
2851 {
2852 char quoted[HTTP_MAX_VALUE * 2 + 4];
2853 /* Quoted string */
2854
2855 fprintf(stderr, "ATTR: auth-info-default=%s,\n",
2856 quote_string(def_username, quoted, sizeof(quoted)));
2857 }
2858 }
2859
2860 if (password && *password && *password_tries < 3)
2861 {
2862 (*password_tries) ++;
2863
2864 cupsSetUser(username);
2865
2866 return (password);
2867 }
2868 else
2869 {
2870 /*
2871 * Give up after 3 tries or if we don't have a password to begin with...
2872 */
2873
2874 return (NULL);
2875 }
2876 }
2877
2878
2879 /*
2880 * 'quote_string()' - Quote a string value.
2881 */
2882
2883 static const char * /* O - Quoted string */
2884 quote_string(const char *s, /* I - String */
2885 char *q, /* I - Quoted string buffer */
2886 size_t qsize) /* I - Size of quoted string buffer */
2887 {
2888 char *qptr, /* Pointer into string buffer */
2889 *qend; /* End of string buffer */
2890
2891
2892 qptr = q;
2893 qend = q + qsize - 5;
2894
2895 if (qend < q)
2896 {
2897 *q = '\0';
2898 return (q);
2899 }
2900
2901 *qptr++ = '\'';
2902 *qptr++ = '\"';
2903
2904 while (*s && qptr < qend)
2905 {
2906 if (*s == '\\' || *s == '\"' || *s == '\'')
2907 {
2908 if (qptr < (qend - 4))
2909 {
2910 *qptr++ = '\\';
2911 *qptr++ = '\\';
2912 *qptr++ = '\\';
2913 }
2914 else
2915 break;
2916 }
2917
2918 *qptr++ = *s++;
2919 }
2920
2921 *qptr++ = '\"';
2922 *qptr++ = '\'';
2923 *qptr = '\0';
2924
2925 return (q);
2926 }
2927
2928
2929 /*
2930 * 'report_attr()' - Report an IPP attribute value.
2931 */
2932
2933 static void
2934 report_attr(ipp_attribute_t *attr) /* I - Attribute */
2935 {
2936 int i; /* Looping var */
2937 char value[1024], /* Value string */
2938 *valptr; /* Pointer into value string */
2939 const char *cached; /* Cached attribute */
2940
2941
2942 /*
2943 * Convert the attribute values into quoted strings...
2944 */
2945
2946 for (i = 0, valptr = value;
2947 i < attr->num_values && valptr < (value + sizeof(value) - 10);
2948 i ++)
2949 {
2950 if (i > 0)
2951 *valptr++ = ',';
2952
2953 switch (attr->value_tag)
2954 {
2955 case IPP_TAG_INTEGER :
2956 case IPP_TAG_ENUM :
2957 snprintf(valptr, sizeof(value) - (size_t)(valptr - value), "%d", attr->values[i].integer);
2958 valptr += strlen(valptr);
2959 break;
2960
2961 case IPP_TAG_TEXT :
2962 case IPP_TAG_NAME :
2963 case IPP_TAG_KEYWORD :
2964 quote_string(attr->values[i].string.text, valptr, (size_t)(value + sizeof(value) - valptr));
2965 valptr += strlen(valptr);
2966 break;
2967
2968 default :
2969 /*
2970 * Unsupported value type...
2971 */
2972
2973 return;
2974 }
2975 }
2976
2977 *valptr = '\0';
2978
2979 _cupsMutexLock(&report_mutex);
2980
2981 if ((cached = cupsGetOption(attr->name, num_attr_cache,
2982 attr_cache)) == NULL || strcmp(cached, value))
2983 {
2984 /*
2985 * Tell the scheduler about the new values...
2986 */
2987
2988 num_attr_cache = cupsAddOption(attr->name, value, num_attr_cache,
2989 &attr_cache);
2990 fprintf(stderr, "ATTR: %s=%s\n", attr->name, value);
2991 }
2992
2993 _cupsMutexUnlock(&report_mutex);
2994 }
2995
2996
2997 /*
2998 * 'report_printer_state()' - Report the printer state.
2999 */
3000
3001 static void
3002 report_printer_state(ipp_t *ipp) /* I - IPP response */
3003 {
3004 ipp_attribute_t *pa, /* printer-alert */
3005 *pam, /* printer-alert-message */
3006 *pmja, /* printer-mandatory-job-attributes */
3007 *psm, /* printer-state-message */
3008 *reasons, /* printer-state-reasons */
3009 *marker; /* marker-* attributes */
3010 char value[1024], /* State/message string */
3011 *valptr; /* Pointer into string */
3012 static int ipp_supplies = -1;
3013 /* Report supply levels? */
3014
3015
3016 /*
3017 * Report alerts and messages...
3018 */
3019
3020 if ((pa = ippFindAttribute(ipp, "printer-alert", IPP_TAG_TEXT)) != NULL)
3021 report_attr(pa);
3022
3023 if ((pam = ippFindAttribute(ipp, "printer-alert-message",
3024 IPP_TAG_TEXT)) != NULL)
3025 report_attr(pam);
3026
3027 if ((pmja = ippFindAttribute(ipp, "printer-mandatory-job-attributes", IPP_TAG_KEYWORD)) != NULL)
3028 {
3029 int i, /* Looping var */
3030 count = ippGetCount(pmja); /* Number of values */
3031
3032 for (i = 0, valptr = value; i < count; i ++, valptr += strlen(valptr))
3033 {
3034 if (i)
3035 snprintf(valptr, sizeof(value) - (size_t)(valptr - value), " %s", ippGetString(pmja, i, NULL));
3036 else
3037 strlcpy(value, ippGetString(pmja, i, NULL), sizeof(value));
3038 }
3039
3040 if (strcmp(value, mandatory_attrs))
3041 {
3042 strlcpy(mandatory_attrs, value, sizeof(mandatory_attrs));
3043 fprintf(stderr, "PPD: cupsMandatory=\"%s\"\n", value);
3044 }
3045 }
3046
3047 if ((psm = ippFindAttribute(ipp, "printer-state-message",
3048 IPP_TAG_TEXT)) != NULL)
3049 {
3050 char *ptr; /* Pointer into message */
3051
3052
3053 strlcpy(value, "INFO: ", sizeof(value));
3054 for (ptr = psm->values[0].string.text, valptr = value + 6;
3055 *ptr && valptr < (value + sizeof(value) - 6);
3056 ptr ++)
3057 {
3058 if (*ptr < ' ' && *ptr > 0 && *ptr != '\t')
3059 {
3060 /*
3061 * Substitute "<XX>" for the control character; sprintf is safe because
3062 * we always leave 6 chars free at the end...
3063 */
3064
3065 sprintf(valptr, "<%02X>", *ptr);
3066 valptr += 4;
3067 }
3068 else
3069 *valptr++ = *ptr;
3070 }
3071
3072 *valptr++ = '\n';
3073 *valptr = '\0';
3074
3075 fputs(value, stderr);
3076 }
3077
3078 /*
3079 * Now report printer-state-reasons, filtering out some of the reasons we never
3080 * want to set...
3081 */
3082
3083 if ((reasons = ippFindAttribute(ipp, "printer-state-reasons",
3084 IPP_TAG_KEYWORD)) == NULL)
3085 return;
3086
3087 update_reasons(reasons, NULL);
3088
3089 /*
3090 * Relay the current marker-* attribute values...
3091 */
3092
3093 if (ipp_supplies < 0)
3094 {
3095 ppd_file_t *ppd; /* PPD file */
3096 ppd_attr_t *ppdattr; /* Attribute in PPD file */
3097
3098 if ((ppd = ppdOpenFile(getenv("PPD"))) != NULL &&
3099 (ppdattr = ppdFindAttr(ppd, "cupsIPPSupplies", NULL)) != NULL &&
3100 ppdattr->value && _cups_strcasecmp(ppdattr->value, "true"))
3101 ipp_supplies = 0;
3102 else
3103 ipp_supplies = 1;
3104
3105 ppdClose(ppd);
3106 }
3107
3108 if (ipp_supplies > 0)
3109 {
3110 if ((marker = ippFindAttribute(ipp, "marker-colors", IPP_TAG_NAME)) != NULL)
3111 report_attr(marker);
3112 if ((marker = ippFindAttribute(ipp, "marker-high-levels",
3113 IPP_TAG_INTEGER)) != NULL)
3114 report_attr(marker);
3115 if ((marker = ippFindAttribute(ipp, "marker-levels",
3116 IPP_TAG_INTEGER)) != NULL)
3117 report_attr(marker);
3118 if ((marker = ippFindAttribute(ipp, "marker-low-levels",
3119 IPP_TAG_INTEGER)) != NULL)
3120 report_attr(marker);
3121 if ((marker = ippFindAttribute(ipp, "marker-message",
3122 IPP_TAG_TEXT)) != NULL)
3123 report_attr(marker);
3124 if ((marker = ippFindAttribute(ipp, "marker-names", IPP_TAG_NAME)) != NULL)
3125 report_attr(marker);
3126 if ((marker = ippFindAttribute(ipp, "marker-types",
3127 IPP_TAG_KEYWORD)) != NULL)
3128 report_attr(marker);
3129 }
3130 }
3131
3132
3133 #if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3134 /*
3135 * 'run_as_user()' - Run the IPP backend as the printing user.
3136 *
3137 * This function uses an XPC-based user agent to run the backend as the printing
3138 * user. We need to do this in order to have access to the user's Kerberos
3139 * credentials.
3140 */
3141
3142 static int /* O - Exit status */
3143 run_as_user(char *argv[], /* I - Command-line arguments */
3144 uid_t uid, /* I - User ID */
3145 const char *device_uri, /* I - Device URI */
3146 int fd) /* I - File to print */
3147 {
3148 const char *auth_negotiate;/* AUTH_NEGOTIATE env var */
3149 xpc_connection_t conn; /* Connection to XPC service */
3150 xpc_object_t request; /* Request message dictionary */
3151 __block xpc_object_t response; /* Response message dictionary */
3152 dispatch_semaphore_t sem; /* Semaphore for waiting for response */
3153 int status = CUPS_BACKEND_FAILED;
3154 /* Status of request */
3155
3156
3157 fprintf(stderr, "DEBUG: Running IPP backend as UID %d.\n", (int)uid);
3158
3159 /*
3160 * Connect to the user agent for the specified UID...
3161 */
3162
3163 conn = xpc_connection_create_mach_service(kPMPrintUIToolAgent,
3164 dispatch_get_global_queue(0, 0), 0);
3165 if (!conn)
3166 {
3167 _cupsLangPrintFilter(stderr, "ERROR",
3168 _("Unable to start backend process."));
3169 fputs("DEBUG: Unable to create connection to agent.\n", stderr);
3170 goto cleanup;
3171 }
3172
3173 xpc_connection_set_event_handler(conn,
3174 ^(xpc_object_t event)
3175 {
3176 xpc_type_t messageType = xpc_get_type(event);
3177
3178 if (messageType == XPC_TYPE_ERROR)
3179 {
3180 if (event == XPC_ERROR_CONNECTION_INTERRUPTED)
3181 fprintf(stderr, "DEBUG: Interrupted connection to service %s.\n",
3182 xpc_connection_get_name(conn));
3183 else if (event == XPC_ERROR_CONNECTION_INVALID)
3184 fprintf(stderr, "DEBUG: Connection invalid for service %s.\n",
3185 xpc_connection_get_name(conn));
3186 else
3187 fprintf(stderr, "DEBUG: Unxpected error for service %s: %s\n",
3188 xpc_connection_get_name(conn),
3189 xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION));
3190 }
3191 });
3192 xpc_connection_set_target_uid(conn, uid);
3193 xpc_connection_resume(conn);
3194
3195 /*
3196 * Try starting the backend...
3197 */
3198
3199 request = xpc_dictionary_create(NULL, NULL, 0);
3200 xpc_dictionary_set_int64(request, "command", kPMStartJob);
3201 xpc_dictionary_set_string(request, "device-uri", device_uri);
3202 xpc_dictionary_set_string(request, "job-id", argv[1]);
3203 xpc_dictionary_set_string(request, "user", argv[2]);
3204 xpc_dictionary_set_string(request, "title", argv[3]);
3205 xpc_dictionary_set_string(request, "copies", argv[4]);
3206 xpc_dictionary_set_string(request, "options", argv[5]);
3207 xpc_dictionary_set_string(request, "auth-info-required",
3208 getenv("AUTH_INFO_REQUIRED"));
3209 if ((auth_negotiate = getenv("AUTH_NEGOTIATE")) != NULL)
3210 xpc_dictionary_set_string(request, "auth-negotiate", auth_negotiate);
3211 xpc_dictionary_set_fd(request, "stdin", fd);
3212 xpc_dictionary_set_fd(request, "stderr", 2);
3213 xpc_dictionary_set_fd(request, "side-channel", CUPS_SC_FD);
3214
3215 sem = dispatch_semaphore_create(0);
3216 response = NULL;
3217
3218 xpc_connection_send_message_with_reply(conn, request,
3219 dispatch_get_global_queue(0,0),
3220 ^(xpc_object_t reply)
3221 {
3222 /* Save the response and wake up */
3223 if (xpc_get_type(reply)
3224 == XPC_TYPE_DICTIONARY)
3225 response = xpc_retain(reply);
3226
3227 dispatch_semaphore_signal(sem);
3228 });
3229
3230 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
3231 xpc_release(request);
3232 dispatch_release(sem);
3233
3234 if (response)
3235 {
3236 child_pid = (pid_t)xpc_dictionary_get_int64(response, "child-pid");
3237
3238 xpc_release(response);
3239
3240 if (child_pid)
3241 fprintf(stderr, "DEBUG: Child PID=%d.\n", (int)child_pid);
3242 else
3243 {
3244 _cupsLangPrintFilter(stderr, "ERROR",
3245 _("Unable to start backend process."));
3246 fputs("DEBUG: No child PID.\n", stderr);
3247 goto cleanup;
3248 }
3249 }
3250 else
3251 {
3252 _cupsLangPrintFilter(stderr, "ERROR",
3253 _("Unable to start backend process."));
3254 fputs("DEBUG: No reply from agent.\n", stderr);
3255 goto cleanup;
3256 }
3257
3258 /*
3259 * Then wait for the backend to finish...
3260 */
3261
3262 request = xpc_dictionary_create(NULL, NULL, 0);
3263 xpc_dictionary_set_int64(request, "command", kPMWaitForJob);
3264 xpc_dictionary_set_fd(request, "stderr", 2);
3265
3266 sem = dispatch_semaphore_create(0);
3267 response = NULL;
3268
3269 xpc_connection_send_message_with_reply(conn, request,
3270 dispatch_get_global_queue(0,0),
3271 ^(xpc_object_t reply)
3272 {
3273 /* Save the response and wake up */
3274 if (xpc_get_type(reply)
3275 == XPC_TYPE_DICTIONARY)
3276 response = xpc_retain(reply);
3277
3278 dispatch_semaphore_signal(sem);
3279 });
3280
3281 dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
3282 xpc_release(request);
3283 dispatch_release(sem);
3284
3285 if (response)
3286 {
3287 status = (int)xpc_dictionary_get_int64(response, "status");
3288
3289 if (status == SIGTERM || status == SIGKILL || status == SIGPIPE)
3290 {
3291 fprintf(stderr, "DEBUG: Child terminated on signal %d.\n", status);
3292 status = CUPS_BACKEND_FAILED;
3293 }
3294 else if (WIFSIGNALED(status))
3295 {
3296 fprintf(stderr, "DEBUG: Child crashed on signal %d.\n", status);
3297 status = CUPS_BACKEND_STOP;
3298 }
3299 else if (WIFEXITED(status))
3300 {
3301 status = WEXITSTATUS(status);
3302 fprintf(stderr, "DEBUG: Child exited with status %d.\n", status);
3303 }
3304
3305 xpc_release(response);
3306 }
3307 else
3308 _cupsLangPrintFilter(stderr, "ERROR",
3309 _("Unable to get backend exit status."));
3310
3311 cleanup:
3312
3313 if (conn)
3314 {
3315 xpc_connection_cancel(conn);
3316 xpc_release(conn);
3317 }
3318
3319 return (status);
3320 }
3321 #endif /* HAVE_GSSAPI && HAVE_XPC */
3322
3323
3324 /*
3325 * 'sigterm_handler()' - Handle 'terminate' signals that stop the backend.
3326 */
3327
3328 static void
3329 sigterm_handler(int sig) /* I - Signal */
3330 {
3331 (void)sig; /* remove compiler warnings... */
3332
3333 write(2, "DEBUG: Got SIGTERM.\n", 20);
3334
3335 #if defined(HAVE_GSSAPI) && defined(HAVE_XPC)
3336 if (child_pid)
3337 {
3338 kill(child_pid, sig);
3339 child_pid = 0;
3340 }
3341 #endif /* HAVE_GSSAPI && HAVE_XPC */
3342
3343 if (!job_canceled)
3344 {
3345 /*
3346 * Flag that the job should be canceled...
3347 */
3348
3349 write(2, "DEBUG: sigterm_handler: job_canceled = 1.\n", 25);
3350
3351 job_canceled = 1;
3352 return;
3353 }
3354
3355 /*
3356 * The scheduler already tried to cancel us once, now just terminate
3357 * after removing our temp file!
3358 */
3359
3360 if (tmpfilename[0])
3361 unlink(tmpfilename);
3362
3363 _exit(1);
3364 }
3365
3366
3367 /*
3368 * 'timeout_cb()' - Handle HTTP timeouts.
3369 */
3370
3371 static int /* O - 1 to continue, 0 to cancel */
3372 timeout_cb(http_t *http, /* I - Connection to server (unused) */
3373 void *user_data) /* I - User data (unused) */
3374 {
3375 (void)http;
3376 (void)user_data;
3377
3378 return (!job_canceled);
3379 }
3380
3381
3382 /*
3383 * 'update_reasons()' - Update the printer-state-reasons values.
3384 */
3385
3386 static void
3387 update_reasons(ipp_attribute_t *attr, /* I - printer-state-reasons or NULL */
3388 const char *s) /* I - STATE: string or NULL */
3389 {
3390 char op; /* Add (+), remove (-), replace (\0) */
3391 cups_array_t *new_reasons; /* New reasons array */
3392 char *reason, /* Current reason */
3393 add[2048], /* Reasons added string */
3394 *addptr, /* Pointer into add string */
3395 rem[2048], /* Reasons removed string */
3396 *remptr; /* Pointer into remove string */
3397 const char *addprefix, /* Current add string prefix */
3398 *remprefix; /* Current remove string prefix */
3399
3400
3401 fprintf(stderr, "DEBUG: update_reasons(attr=%d(%s%s), s=\"%s\")\n",
3402 attr ? attr->num_values : 0, attr ? attr->values[0].string.text : "",
3403 attr && attr->num_values > 1 ? ",..." : "", s ? s : "(null)");
3404
3405 /*
3406 * Create an array of new reason keyword strings...
3407 */
3408
3409 if (attr)
3410 {
3411 int i; /* Looping var */
3412
3413 new_reasons = cupsArrayNew((cups_array_func_t)strcmp, NULL);
3414 op = '\0';
3415
3416 for (i = 0; i < attr->num_values; i ++)
3417 {
3418 reason = attr->values[i].string.text;
3419
3420 if (strcmp(reason, "none") &&
3421 strcmp(reason, "none-report") &&
3422 strcmp(reason, "paused") &&
3423 strncmp(reason, "spool-area-full", 15) &&
3424 strcmp(reason, "com.apple.print.recoverable-warning") &&
3425 strncmp(reason, "cups-", 5))
3426 cupsArrayAdd(new_reasons, reason);
3427 }
3428 }
3429 else if (s)
3430 {
3431 if (*s == '+' || *s == '-')
3432 op = *s++;
3433 else
3434 op = '\0';
3435
3436 new_reasons = _cupsArrayNewStrings(s, ',');
3437 }
3438 else
3439 return;
3440
3441 /*
3442 * Compute the changes...
3443 */
3444
3445 add[0] = '\0';
3446 addprefix = "STATE: +";
3447 addptr = add;
3448 rem[0] = '\0';
3449 remprefix = "STATE: -";
3450 remptr = rem;
3451
3452 fprintf(stderr, "DEBUG2: op='%c', new_reasons=%d, state_reasons=%d\n",
3453 op ? op : ' ', cupsArrayCount(new_reasons),
3454 cupsArrayCount(state_reasons));
3455
3456 _cupsMutexLock(&report_mutex);
3457
3458 if (op == '+')
3459 {
3460 /*
3461 * Add reasons...
3462 */
3463
3464 for (reason = (char *)cupsArrayFirst(new_reasons);
3465 reason;
3466 reason = (char *)cupsArrayNext(new_reasons))
3467 {
3468 if (!cupsArrayFind(state_reasons, reason))
3469 {
3470 if (!strncmp(reason, "cups-remote-", 12))
3471 {
3472 /*
3473 * If we are setting cups-remote-xxx, remove all other cups-remote-xxx
3474 * keywords...
3475 */
3476
3477 char *temp; /* Current reason in state_reasons */
3478
3479 cupsArraySave(state_reasons);
3480
3481 for (temp = (char *)cupsArrayFirst(state_reasons);
3482 temp;
3483 temp = (char *)cupsArrayNext(state_reasons))
3484 if (!strncmp(temp, "cups-remote-", 12))
3485 {
3486 snprintf(remptr, sizeof(rem) - (size_t)(remptr - rem), "%s%s", remprefix, temp);
3487 remptr += strlen(remptr);
3488 remprefix = ",";
3489
3490 cupsArrayRemove(state_reasons, temp);
3491 break;
3492 }
3493
3494 cupsArrayRestore(state_reasons);
3495 }
3496
3497 cupsArrayAdd(state_reasons, reason);
3498
3499 snprintf(addptr, sizeof(add) - (size_t)(addptr - add), "%s%s", addprefix, reason);
3500 addptr += strlen(addptr);
3501 addprefix = ",";
3502 }
3503 }
3504 }
3505 else if (op == '-')
3506 {
3507 /*
3508 * Remove reasons...
3509 */
3510
3511 for (reason = (char *)cupsArrayFirst(new_reasons);
3512 reason;
3513 reason = (char *)cupsArrayNext(new_reasons))
3514 {
3515 if (cupsArrayFind(state_reasons, reason))
3516 {
3517 snprintf(remptr, sizeof(rem) - (size_t)(remptr - rem), "%s%s", remprefix, reason);
3518 remptr += strlen(remptr);
3519 remprefix = ",";
3520
3521 cupsArrayRemove(state_reasons, reason);
3522 }
3523 }
3524 }
3525 else
3526 {
3527 /*
3528 * Replace reasons...
3529 */
3530
3531 for (reason = (char *)cupsArrayFirst(state_reasons);
3532 reason;
3533 reason = (char *)cupsArrayNext(state_reasons))
3534 {
3535 if (strncmp(reason, "cups-", 5) && !cupsArrayFind(new_reasons, reason))
3536 {
3537 snprintf(remptr, sizeof(rem) - (size_t)(remptr - rem), "%s%s", remprefix, reason);
3538 remptr += strlen(remptr);
3539 remprefix = ",";
3540
3541 cupsArrayRemove(state_reasons, reason);
3542 }
3543 }
3544
3545 for (reason = (char *)cupsArrayFirst(new_reasons);
3546 reason;
3547 reason = (char *)cupsArrayNext(new_reasons))
3548 {
3549 if (!cupsArrayFind(state_reasons, reason))
3550 {
3551 cupsArrayAdd(state_reasons, reason);
3552
3553 snprintf(addptr, sizeof(add) - (size_t)(addptr - add), "%s%s", addprefix, reason);
3554 addptr += strlen(addptr);
3555 addprefix = ",";
3556 }
3557 }
3558 }
3559
3560 _cupsMutexUnlock(&report_mutex);
3561
3562 /*
3563 * Report changes and return...
3564 */
3565
3566 if (add[0] && rem[0])
3567 fprintf(stderr, "%s\n%s\n", add, rem);
3568 else if (add[0])
3569 fprintf(stderr, "%s\n", add);
3570 else if (rem[0])
3571 fprintf(stderr, "%s\n", rem);
3572 }
Unnamed repository; edit this file 'description' to name the repository.