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