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